*

lsh

2 天以前 8c0d2c49eb091aedd053d8f7a1be28b67ce8d0c3

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

@@ -4,11 +4,10 @@
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.R;
import com.core.common.*;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.AgvTaskAssignmentParam;
import com.zy.asrs.entity.param.ArmOrderAssignmentParam;
import com.zy.asrs.entity.param.ArmTaskAssignmentParam;
import com.zy.asrs.entity.param.CombParam;
@@ -20,6 +19,7 @@
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
import com.zy.asrs.utils.core.ReturnT;
import com.zy.common.constant.AgvConstant;
import com.zy.common.constant.ArmConstant;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.MatDto;
@@ -105,6 +105,8 @@
    private BasRgvMapService basRgvMapService;
    @Autowired
    private BasArmService basArmService;
    @Autowired
    private BasAgvMastService basAgvMastService;
    @Autowired
    private BasArmMastService basArmMastService;
    @Autowired
@@ -491,10 +493,10 @@
                    if (Cools.isEmpty(staDesc)) {
                        News.error(""+mark+" - 2"+" - 入库路径不存在！type_no={},stn_no={},crn_no={}", wrkMast.getIoType(), pickSta.getStaNo(), wrkMast.getCrnNo());
                        staProtocol.setWorkNo(wrkNo++);
                        staProtocol.setStaNo((short) (pickSta.getStaNo().shortValue()-(short)1));
                        staProtocol.setStaNo((short) (pickSta.getStaNo().shortValue()));
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        log.error("输送线下发4："+9989+","+(pickSta.getStaNo().shortValue()-(short)1));
                        log.error("输送线下发4："+9996+","+(pickSta.getStaNo().shortValue()-(short)1));
                        //LED
                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
                        // led 异常显示
@@ -518,6 +520,14 @@
                        Date now = new Date();
                        // 堆垛机站点(目标站)
                        Integer staNo = staDesc.getCrnStn();
                        if(wrkMast.getSourceStaNo() > 2000){
                            switch (wrkMast.getCrnNo()){
                                case 1: staNo = 2004;break;
                                case 2: staNo = 2010;break;
                                case 4: staNo = 2022;break;
                                case 5: staNo = 2028;break;
                            }
                        }
                        // 更新工作档数据状态
                        wrkMast.setIoTime(now);
                        wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
@@ -547,7 +557,7 @@

                    // 更新站点信息 且 下发plc命令
                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                    staProtocol.setStaNo((short) 161);
                    staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    log.error("输送线下发5："+wrkMast.getWrkNo()+","+wrkMast.getStaNo());
@@ -747,6 +757,101 @@
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
                    WrkMast wrkMast9997 = wrkMastMapper.selectPakOutStep9997(staProtocol.getSiteId());
                    WrkMast wrkMast9996 = wrkMastMapper.selectPakOutStep9996(staProtocol.getSiteId());

                    if(crnSlave.getId() == 3 && wrkMast9997 != null){
                        WrkMast wrkMast107 = wrkMastMapper.selectPakOutStep107(wrkMast9997.getBarcode());
                        // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                        CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn,3);
                        CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                        if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) {
                            // 移动中
                            continue;
                        }
                        //  判断堆垛机状态等待确认
                        if (crnProtocol.modeType == CrnModeType.AUTO &&  crnProtocol.getTaskNo()== 9997
                                && crnProtocol.statusType == CrnStatusType.WAITING
                                && crnProtocol.forkPosType == CrnForkPosType.HOME) {
                            log.info("堆垛机出库完成 - 开始执行");

                            // 命令下发区 --------------------------------------------------------------------------

                            // 下发站点信息
                            staProtocol.setWorkNo(wrkMast107.getWrkNo());
                            staProtocol.setStaNo(RouteUtils.CrnStaEnd(wrkMast107.getStaNo(),wrkMast107.getSourceStaNo()));
                            if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                                log.info(staProtocol.getWorkNo()+","+staProtocol.getStaNo()+"输送线出库命令下发失败");
                                continue;
                            }else {
                                log.info(staProtocol.getWorkNo()+","+staProtocol.getStaNo()+"输送线出库命令下发成功");
                            }

                            // 更新工作档状态为14失败
                            wrkMast9997.setWrkSts(14L);
                            wrkMast9997.setCrnEndTime(new Date());
                            if (wrkMastMapper.updateById(wrkMast9997) != 0) {
                                // 复位堆垛机
                                log.error("出库任务完成下发堆垛机复位,{}", wrkMast9997.getWrkNo());
                                crnThread.setResetFlag(true);
                            } else {
                                News.error(""+mark+" - 1"+" - 更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast9997.getWrkNo());
                            }

                        }else {
                            News.errorNoLog(""+mark+" - 6"+" - 堆垛机信息不符合入库条件！！！"
                                    +" 堆垛机状态："+crnProtocol.modeType+"==自动AUTO：" + CrnModeType.AUTO
                                    +"、堆垛机任务号："+crnProtocol.getTaskNo()+"==工作档任务号：" + wrkMast9997.getWrkNo().shortValue()
                                    +"、状态枚举："+crnProtocol.statusType+"==WAITING：90 //任务完成等待WCS确认)：" + CrnStatusType.WAITING
                                    +"、货叉位置："+crnProtocol.forkPosType+"==HOME：0  // 货叉原位：" + CrnForkPosType.HOME);
                        }
                    }
                    if(crnSlave.getId() == 3 && wrkMast9996 != null){
                        WrkMast wrkMast107 = wrkMastMapper.selectPakOutStep107(wrkMast9996.getBarcode());
                        // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                        CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, 3);
                        CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                        if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) {
                            // 移动中
                            continue;
                        }
                        //  判断堆垛机状态等待确认
                        if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo() == 9996
                                && crnProtocol.statusType == CrnStatusType.WAITING
                                && crnProtocol.forkPosType == CrnForkPosType.HOME) {
                            log.info("堆垛机出库完成 - 开始执行");

                            // 命令下发区 --------------------------------------------------------------------------

                            // 下发站点信息
                            staProtocol.setWorkNo(wrkMast107.getWrkNo());
                            staProtocol.setStaNo(RouteUtils.CrnStaEnd(wrkMast107.getStaNo(),wrkMast107.getSourceStaNo()));
                            if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                                log.info(staProtocol.getWorkNo()+","+staProtocol.getStaNo()+"输送线出库命令下发失败");
                                continue;
                            }else {
                                log.info(staProtocol.getWorkNo()+","+staProtocol.getStaNo()+"输送线出库命令下发成功");
                            }

                            // 更新工作档状态为14失败
                            wrkMast9996.setWrkSts(14L);
                            wrkMast9996.setCrnEndTime(new Date());
                            if (wrkMastMapper.updateById(wrkMast9996) != 0) {
                                // 复位堆垛机
                                log.error("出库任务完成下发堆垛机复位,{}", wrkMast9996.getWrkNo());
                                crnThread.setResetFlag(true);
                            } else {
                                News.error(""+mark+" - 1"+" - 更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast9996.getWrkNo());
                            }

                        }else {
                            News.errorNoLog(""+mark+" - 6"+" - 堆垛机信息不符合入库条件！！！"
                                    +" 堆垛机状态："+crnProtocol.modeType+"==自动AUTO：" + CrnModeType.AUTO
                                    +"、堆垛机任务号："+crnProtocol.getTaskNo()+"==工作档任务号：" + wrkMast9996.getWrkNo().shortValue()
                                    +"、状态枚举："+crnProtocol.statusType+"==WAITING：90 //任务完成等待WCS确认)：" + CrnStatusType.WAITING
                                    +"、货叉位置："+crnProtocol.forkPosType+"==HOME：0  // 货叉原位：" + CrnForkPosType.HOME);
                        }
                    }
                    // 查询工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(staProtocol.getSiteId());
                    if (wrkMast == null) {
@@ -828,14 +933,17 @@
                    staProtocolOut = staProtocolOut.clone();
                }

                if (staProtocolOut.getWorkNo() != null && staProtocolOut.getStaNo() == 4006) {
                    WrkMast wrkMastOut = wrkMastMapper.selectByWrkNo(staProtocolOut.getWorkNo());
                WrkMast wrkMastOut = wrkMastMapper.selectByWrkNo(staProtocolOut.getWorkNo());
                if(wrkMastOut == null ){
                    continue;
                }
                if (staProtocolOut.getWorkNo() != null && wrkMastOut.getStaNo() == 4006) {
                    WrkMast wrkMast = wrkMastMapper.selectByWrkNo(9997);
                    if (wrkMastOut == null) {
                        continue;
                    }
                    if (wrkMast != null) {
                        News.info("已存在斜街任务，等待任务完成");
//                        News.info("已存在斜街任务，等待任务完成");
                        continue;
                    }
                    try {
@@ -868,7 +976,13 @@
                    }
                }
            }
            if(staProtocolIn.getWorkNo() != null &&staProtocolIn.getStaNo() != 4001){
            if(staProtocolIn.getWorkNo() != null && staProtocolIn.getStaNo() != 4001){
                WrkMast wrkMastCrn = wrkMastMapper.selectByWrkNo(staProtocolIn.getWorkNo());
                if(wrkMastCrn!=null){
                    if(wrkMastCrn.getCrnNo() == 3 ){
                        continue;
                    }
                }
                WrkMast wrkMastIn = wrkMastMapper.selectByWrkNo(staProtocolIn.getWorkNo());
                WrkMast wrkMast = wrkMastMapper.selectByWrkNo(9996);
                if(wrkMastIn == null){
@@ -1040,8 +1154,10 @@
            } else {
                staProtocol = staProtocol.clone();
            }
//            if (slave.getId() == 3) {
//                SiemensDevpThread devpThread1 = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
//            WrkMast wrkMast9996 = wrkMastMapper.selectByWrkNo9996(9996);
//
//            if (slave.getId() == 3 && wrkMast9996 != null) {
//                SiemensDevpThread devpThread1 = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp,2);
//                StaProtocol staProtocol2 = devpThread1.getStation().get(4001);
//                if (staProtocol2 == null) {
//                    News.infoNoLog("" + mark + " - 2" + " - 3" + " - 堆垛机出库站信息(staProtocol!=null继续执行,否则循环终止)：staProtocol=" + staProtocol2);
@@ -1049,14 +1165,13 @@
//                } else {
//                    staProtocol2 = staProtocol2.clone();
//                }
//                WrkMast wrkMast9999 = wrkMastMapper.selectByWrkNo(9996);
//                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
//                if (staDetl == null) {
//                    News.error(""+mark+" - 2"+" - 5"+" - 出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
//                    break;
////                    continue;
//                }
//                if(wrkMast9999 != null && staProtocol2.isAutoing() && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")){
//                if( staProtocol2.isAutoing() && staProtocol2.isLoading() && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")){
//                    // 堆垛机控制过滤
//                    if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
////                        continue;
@@ -1073,23 +1188,30 @@
//                    crnCommand.setTaskNo((short) 9996); // 工作号
////                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
//                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
//                    crnCommand.setSourcePosX((short) 5);     // 源库位排
//                    crnCommand.setSourcePosY((short) 1);     // 源库位列
//                    crnCommand.setSourcePosZ((short) 4);     // 源库位层
//                    crnCommand.setDestinationPosX((short) 6);     // 目标库位排
//                    crnCommand.setDestinationPosY((short) 1);     // 目标库位列
//                    crnCommand.setDestinationPosZ((short) 1);     // 目标库位层
//                    crnCommand.setSourcePosX((short) 9);     // 源库位排
//                    crnCommand.setSourcePosY((short) 52);     // 源库位列
//                    crnCommand.setSourcePosZ((short) 3);     // 源库位层
//                    if(wrkMast9996.getStaNo()>2000){
//                        crnCommand.setDestinationPosX((short) 9);     // 目标库位排
//                        crnCommand.setDestinationPosY((short) 52);     // 目标库位列
//                        crnCommand.setDestinationPosZ((short) 2);     // 目标库位层
//                    }else{
//                        crnCommand.setDestinationPosX((short) 11);     // 目标库位排
//                        crnCommand.setDestinationPosY((short) 52);     // 目标库位列
//                        crnCommand.setDestinationPosZ((short) 1);     // 目标库位层
//                    }
//
////                crnCommand.setTraySize(sourceSta.getLocType1() == 2);     //库位类型
//                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast9999.getCrnNo(), new Task(2, crnCommand))) {
//                        News.error("" + mark + " - 2" + " - 13" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast9999.getCrnNo(), JSON.toJSON(crnCommand));
//                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast9996.getCrnNo(), new Task(2, crnCommand))) {
//                        News.error("" + mark + " - 2" + " - 13" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast9996.getCrnNo(), JSON.toJSON(crnCommand));
//                    } else {
//                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
//                        Date now = new Date();
//                        wrkMast9999.setWrkSts(3L);
//                        wrkMast9999.setCrnStrTime(now);
//                        wrkMast9999.setModiTime(now);
//                        if (wrkMastMapper.updateById(wrkMast9999) == 0) {
//                            News.error("" + mark + " - 2" + " - 14" + " - 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast9999.getWrkNo());
//                        wrkMast9996.setWrkSts(3L);
//                        wrkMast9996.setCrnStrTime(now);
//                        wrkMast9996.setModiTime(now);
//                        if (wrkMastMapper.updateById(wrkMast9996) == 0) {
//                            News.error("" + mark + " - 2" + " - 14" + " - 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast9996.getWrkNo());
//                        }
//                        break;
//                    }
@@ -1239,61 +1361,170 @@
            // 获取工作状态为11（生成出库ID）的出库工作档
//            WrkMast wrkMast = wrkMastMapper.selectPakOutStep1(slave.getId(), crnStn.getStaNo());
            List<WrkMast> wrkMasts = wrkMastMapper.selectPakOutStep11(slave.getId(), crnStn.getStaNo());
//            if (slave.getId() == 3) {
//                SiemensDevpThread devpThread1 = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
//                StaProtocol staProtocol2 = devpThread1.getStation().get(1015);
//                if (staProtocol2 == null) {
//                    News.infoNoLog("" + mark + " - 2" + " - 3" + " - 堆垛机出库站信息(staProtocol!=null继续执行,否则循环终止)：staProtocol=" + staProtocol2);
//                    break;
//                } else {
//                    staProtocol2 = staProtocol2.clone();
//                }
//                WrkMast wrkMast9999 = wrkMastMapper.selectByWrkNo(9997);
//                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
//                if (staDetl == null) {
//                    News.error(""+mark+" - 2"+" - 5"+" - 出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
//                    break;
////                    continue;
//                }
//                if(wrkMast9999 != null && staProtocol2.isAutoing() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")){
//                    // 堆垛机控制过滤
//                    if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
////                        continue;
//                        break;
//                    }
//                    // 已经存在吊车执行任务时，则过滤
//                    if (wrkMastMapper.selectWorking(slave.getId()) != null) {
//                        break;
////                        return;
//                    }
//                    // 1.堆垛机开始移动
//                    CrnCommand crnCommand = new CrnCommand();
//                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
//                    crnCommand.setTaskNo((short) 9997); // 工作号
////                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
//                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
//                    crnCommand.setSourcePosX((short) 5);     // 源库位排
//                    crnCommand.setSourcePosY((short) 1);     // 源库位列
//                    crnCommand.setSourcePosZ((short) 1);     // 源库位层
//                    crnCommand.setDestinationPosX((short) 6);     // 目标库位排
//                    crnCommand.setDestinationPosY((short) 1);     // 目标库位列
//                    crnCommand.setDestinationPosZ((short) 4);     // 目标库位层
////                crnCommand.setTraySize(sourceSta.getLocType1() == 2);     //库位类型
//                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast9999.getCrnNo(), new Task(2, crnCommand))) {
//                        News.error("" + mark + " - 2" + " - 13" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast9999.getCrnNo(), JSON.toJSON(crnCommand));
//                    } else {
//                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
//                        Date now = new Date();
//                        wrkMast9999.setWrkSts(12L);
//                        wrkMast9999.setCrnStrTime(now);
//                        wrkMast9999.setModiTime(now);
//                        if (wrkMastMapper.updateById(wrkMast9999) == 0) {
//                            News.error("" + mark + " - 2" + " - 14" + " - 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast9999.getWrkNo());
//                        }
//                        break;
//                    }
//                }
//            }
            WrkMast wrkMast9997 = wrkMastMapper.selectByWrkNo9997(9997);
            WrkMast wrkMast9996 = wrkMastMapper.selectByWrkNo9997(9996);


            if (slave.getId() == 3 && wrkMast9997 != null) {
                SiemensDevpThread devpThread1 = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                StaProtocol staProtocol2 = devpThread1.getStation().get(1015);
                if (staProtocol2 == null) {
                    News.infoNoLog("" + mark + " - 2" + " - 3" + " - 堆垛机出库站信息(staProtocol!=null继续执行,否则循环终止)：staProtocol=" + staProtocol2);
                    break;
                } else {
                    staProtocol2 = staProtocol2.clone();
                }
                SiemensDevpThread devpThread2 = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 2);
                StaProtocol staProtocol3 = devpThread2.getStation().get(2016);
                if (staProtocol3 == null) {
                    News.infoNoLog("" + mark + " - 2" + " - 3" + " - 堆垛机出库站信息(staProtocol!=null继续执行,否则循环终止)：staProtocol=" + staProtocol2);
                    break;
                } else {
                    staProtocol3 = staProtocol3.clone();
                }
                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                if (staDetl == null) {
                    News.error(""+mark+" - 2"+" - 5"+" - 出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    break;
//                    continue;
                }
                if(staProtocol2.isLoading() && staProtocol2.isAutoing() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")){
                    // 堆垛机控制过滤
                    if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
//                        continue;
                        break;
                    }
                    // 已经存在吊车执行任务时，则过滤
                    if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                        break;
//                        return;
                    }
                    // 1.堆垛机开始移动
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                    crnCommand.setTaskNo((short) 9997); // 工作号
//                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX((short) 9);     // 源库位排
                    crnCommand.setSourcePosY((short) 52);     // 源库位列
                    crnCommand.setSourcePosZ((short) 1);     // 源库位层
                    crnCommand.setDestinationPosX((short) 11);     // 目标库位排
                    crnCommand.setDestinationPosY((short) 52);     // 目标库位列
                    crnCommand.setDestinationPosZ((short) 3);     // 目标库位层
//                crnCommand.setTraySize(sourceSta.getLocType1() == 2);     //库位类型
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast9997.getCrnNo(), new Task(2, crnCommand))) {
                        News.error("" + mark + " - 2" + " - 13" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast9997.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                        Date now = new Date();
                        wrkMast9997.setWrkSts(12L);
                        wrkMast9997.setCrnStrTime(now);
                        wrkMast9997.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast9997) == 0) {
                            News.error("" + mark + " - 2" + " - 14" + " - 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast9997.getWrkNo());
                        }
                        break;
                    }
                }
                if(staProtocol3.isLoading() && staProtocol3.isAutoing()){
                    // 堆垛机控制过滤
                    if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
//                        continue;
                        break;
                    }
                    // 已经存在吊车执行任务时，则过滤
                    if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                        break;
//                        return;
                    }
                    // 1.堆垛机开始移动
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                    crnCommand.setTaskNo((short) 9997); // 工作号
//                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX((short) 11);     // 源库位排
                    crnCommand.setSourcePosY((short) 52);     // 源库位列
                    crnCommand.setSourcePosZ((short) 2);     // 源库位层
                    crnCommand.setDestinationPosX((short) 11);     // 目标库位排
                    crnCommand.setDestinationPosY((short) 52);     // 目标库位列
                    crnCommand.setDestinationPosZ((short) 3);     // 目标库位层
//                crnCommand.setTraySize(sourceSta.getLocType1() == 2);     //库位类型
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast9997.getCrnNo(), new Task(2, crnCommand))) {
                        News.error("" + mark + " - 2" + " - 13" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast9997.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                        Date now = new Date();
                        wrkMast9997.setWrkSts(12L);
                        wrkMast9997.setCrnStrTime(now);
                        wrkMast9997.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast9997) == 0) {
                            News.error("" + mark + " - 2" + " - 14" + " - 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast9997.getWrkNo());
                        }
                        break;
                    }
                }
            }
            if (slave.getId() == 3 && wrkMast9996 != null) {
                SiemensDevpThread devpThread2 = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 2);
                StaProtocol staProtocol4001 = devpThread2.getStation().get(4001);
                if (staProtocol4001 == null) {
                    News.infoNoLog("" + mark + " - 2" + " - 3" + " - 堆垛机出库站信息(staProtocol!=null继续执行,否则循环终止)：staProtocol=" + staProtocol4001);
                    break;
                } else {
                    staProtocol4001 = staProtocol4001.clone();
                }
                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                if (staDetl == null) {
                    News.error(""+mark+" - 2"+" - 5"+" - 出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    break;
//                    continue;
                }
                if(staProtocol4001.isLoading() && staProtocol4001.isAutoing() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")){
                    // 堆垛机控制过滤
                    if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
//                        continue;
                        break;
                    }
                    // 已经存在吊车执行任务时，则过滤
                    if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                        break;
//                        return;
                    }
                    // 1.堆垛机开始移动
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                    crnCommand.setTaskNo((short) 9996); // 工作号
//                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX((short) 9);     // 源库位排
                    crnCommand.setSourcePosY((short) 52);     // 源库位列
                    crnCommand.setSourcePosZ((short) 3);     // 源库位层
                    if(wrkMast9996.getStaNo()>2000){
                        crnCommand.setDestinationPosX((short) 9);     // 目标库位排
                        crnCommand.setDestinationPosY((short) 52);     // 目标库位列
                        crnCommand.setDestinationPosZ((short) 2);     // 目标库位层
                    }else{
                        crnCommand.setDestinationPosX((short) 11);     // 目标库位排
                        crnCommand.setDestinationPosY((short) 52);     // 目标库位列
                        crnCommand.setDestinationPosZ((short) 1);     // 目标库位层
                    }
//                crnCommand.setTraySize(sourceSta.getLocType1() == 2);     //库位类型
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast9996.getCrnNo(), new Task(2, crnCommand))) {
                        News.error("" + mark + " - 2" + " - 13" + " - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast9996.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                        Date now = new Date();
                        wrkMast9996.setWrkSts(12L);
                        wrkMast9996.setCrnStrTime(now);
                        wrkMast9996.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast9996) == 0) {
                            News.error("" + mark + " - 2" + " - 14" + " - 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast9996.getWrkNo());
                        }
                        break;
                    }
                }
            }
            for (WrkMast wrkMast : wrkMasts) {
                if (wrkMast == null) {
                    continue;
@@ -3253,6 +3484,11 @@
                basRgvService.updateById(basRgv);
                rgvThread.setPakMk(true);
            }
            List<WrkMastSta> wrkMastStaPakingNum = wrkMastStaService.selectPakingWrkNum(basRgv.getRgvNo());
            if(wrkMastStaPakingNum.size() <1){
                basRgv.setPakAll("1"); //防止无其他任务时，连续取货无法恢复
                basRgvService.updateById(basRgv);
            }

        }
    }
@@ -3282,6 +3518,7 @@
                basRgv.setPakAll("1");
                basRgvService.updateById(basRgv);
            }

            // 只有当RGV空闲 并且 无任务时才继续执行
            if (rgvProtocol.getStatusType1() == RgvStatusType.IDLE &&
                    rgvProtocol.getModeType() == RgvModeType.AUTO && rgvThread.isPakMk()
@@ -3324,58 +3561,14 @@
            WrkMastSta wrkMastSta1 = wrkMastStaMapper.selectByWorkSta(1, (int) rgvProtocol.getRgvNo());
            if(wrkMastSta1 != null && wrkMastSta2 != null){
                rgvThread.setPakMk(false);  //小车双工位锁定

            }
//            if(!rgvThread.isPakToCrn()){
//                rgvRunWrkToCrn(rgv, rgvProtocol,mark); //若小车取到一个接驳任务，第二个工位只能取接驳任务
//            }

//            if(rgvProtocol.getStatusType1() == RgvStatusType.IDLE && rgvProtocol.getTaskNo1() == 0 && rgvThread.isPakIn() && rgvThread.isPakRgv()){
//                rgvPreScheduling();//若暂无下发任务预调度提前到取货点
//            }


//            if (rgvProtocol.getStatusType1() == RgvStatusType.IDLE && rgvProtocol.getModeType() == RgvModeType.AUTO) {
//                //小车执行放货任务
//                rgvOutExecute();
//
//            }
        }
    }
    public synchronized void rgvRunWrkMastInTest(){
        BasRgvMap basRgvMap = basRgvMapMapper.selectById(1);
        List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
        basRgvMap.setNowRoute(1021); //更新小车当前位置站点号
        WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(342);//根据站点工作号和小车工作范围检索任务档

//        WrkMastSta wrkMastSta2 = wrkMastStaMapper.selectByWorkSta(2, 1);
        boolean result = false;
//        if(wrkMastSta2 != null && rgvProtocol.getRgvNo() == 1){ //距离计算   2楼单入库口不需要计算
//            result = rgvCalcDistance((int) rgvProtocol.getRgvNo(),wrkMastSta2.getStaEnd(),wrkMastSta.getStaStart());//工位2放货站点，工位1取货站点
//        }
//        if(result){//若小车距离放货点距离近于取货点则跳过取货 true跳过取货/false优先取货
//            rgvThread.setPakRgv(false);
//            continue;
//        }
        wrkMastSta.setWorkSta(1);
        wrkMastSta.setRgvNo(1);
        wrkMastSta.setStaStart(1035);
        Short direction = 2;//双工位最终抵达位置
        boolean sign = false;
//        sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta,direction,); //命令下发
        if (sign){
            wrkMastSta.setWrkSts(1);
            try{
                wrkMastStaMapper.updateById(wrkMastSta);
                log.error("更新小车任务成功");
            }catch (Exception e){
                log.error("更新小车任务失败");
            }
//            rgvThread.setPakOut(false);//出库不允许
            boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd(),"2526");
            if (!signMap){
                log.error("货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
            }
        } else {
            log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
        }
    }
    /**
@@ -3476,7 +3669,7 @@

                if(wrkMastSta3 != null ){
                    List<WrkMastSta> wrkMastStaPaking = wrkMastStaService.selectPakingWrk(wrkMastSta3.getStaStart());
                    if(wrkMastStaPaking.size() < 1){//已有标记不再标记
                    if(wrkMastStaPaking.size() < 1 ){//已有标记不再标记
                        wrkMastSta3.setMk(1);
                        basRgv.setPakAll("0");
                        basRgvService.updateById(basRgv);
@@ -3580,6 +3773,9 @@
                continue;
            }
            WrkMastSta wrkMastSta1 = wrkMastStaMapper.selectByWrkNo( rgvProtocol.getTaskNo1());
            if(basRgv.getPakToCrn().equals("0")){
                wrkMastSta = wrkMastStaMapper.selectNoInterfereCrn(route, route, Long.valueOf(staProtocol.getWorkNo()));//处理接驳任务时，连续只取接驳任务
            }
            boolean result = false;
            if(wrkMastSta1!= null && rgvProtocol.getRgvNo() == 1){ //距离计算   2楼单入库口不需要计算
                result = rgvCalcDistance((int) rgvProtocol.getRgvNo(),wrkMastSta1.getStaEnd(),wrkMastSta.getStaStart());//工位2放货站点，工位1取货站点
@@ -3588,7 +3784,6 @@
                basRgv.setPakRgv("0");
                basRgvService.updateById(basRgv);

//                rgvThread.setPakRgv(false);
                continue;
            }
            wrkMastSta.setWorkSta(wrkMastSta1 !=null ? 2 : 1);//若1号工位有任务给2号工位
@@ -3599,8 +3794,11 @@
                if(LEFT_POSITION.contains(wrkMastSta.getStaEnd())){
                    basRgv.setPakToCrn("0");
                    basRgvService.updateById(basRgv);

//                    rgvThread.setPakToCrn(false); //锁定小车只能接接驳任务
                    if(wrkMastSta3 != null){
                        if(!LEFT_POSITION.contains(wrkMastSta3.getStaEnd())){
                            wrkMastSta3 = null;//若接驳第二位不接驳时取消连续取货
                        }
                    }
                }

                if(wrkMastSta3 != null ){
@@ -3640,94 +3838,137 @@
    /**
     * 小车出库接驳任务取货下发
     */
//    public synchronized void rgvRunWrkToCrn(RgvSlave slave, RgvProtocol rgvProtocol,Integer mark){
//        for (RgvSlave.RgvStn rgvStn : slave.getRgvOutTStn()) {//rgv出库取货站点
//            boolean flag = false;
//            //遍历rgv入库取货站点
//            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, rgvStn.getDevpPlcId());
//            StaProtocol staProtocol = devpThread.getStation().get(rgvStn.getStaNo());
//            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, (int) rgvProtocol.getRgvNo());
//            StaProtocol staProtocol2 = null;
//            if(rgvStn.getStaNo2()!= null ){
//                staProtocol2 = devpThread.getStation().get(rgvStn.getStaNo2());
//                if (staProtocol2 == null) {
//                    News.infoNoLog("" + mark + " - 1" + " - 1" + " - Rgv入库站信息(staProtocol!=null继续执行)：staProtocol=" + staProtocol);
//                    continue;
//                } else {
//                    staProtocol2 = staProtocol2.clone();
//                }
//                BasDevp staDetl2 = basDevpService.selectById(rgvStn.getStaNo2());
//                if (staDetl2 == null) {
//                    News.error("" + mark + " - 1" + " - 2" + " - 入库 ===>>Rgv站点在数据库不存在, 站点编号={}", rgvStn.getStaNo());
//                    continue;
//                }
//            }
//            if (staProtocol == null) {
//                News.infoNoLog("" + mark + " - 1" + " - 1" + " - Rgv出库站信息(staProtocol!=null继续执行)：staProtocol=" + staProtocol);
//                continue;
//            } else {
//                staProtocol = staProtocol.clone();
//            }
//
//            // 查询站点详细信息
//            BasDevp staDetl = basDevpService.selectById(rgvStn.getStaNo());
//            if (staDetl == null) {
//                News.error("" + mark + " - 1" + " - 2" + " - 出库 ===>>Rgv站点在数据库不存在, 站点编号={}", rgvStn.getStaNo());
//                continue;
//            }
//
//            if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0
//                    && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")) {
//                flag = true;
//            }
//            if (!flag) {
//                News.errorNoLog("" + mark + " - 1" + " - 3" + " - Rgv出库取货站信息(以下需要全true):"
//                        + "自动信号" + staProtocol.isAutoing() + "有物信号" + staProtocol.isLoading()
//                        + "工作号>0" + staProtocol.getWorkNo() + "可入信号" + staProtocol.isOutEnable()
//                        + "能入信号（wms设置）.equals(\"Y\")" + staDetl.getCanouting());
//                continue;
//            }
//            BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
//            List<Integer> route = new ArrayList<>();
//            switch (rgvProtocol.getRgvNo()){
//                case 1: route = RouteUtils.getRouteOne();break;
//                case 2: route = RouteUtils.getRouteTwo();break;
//            }
//            basRgvMap.setNowRoute(rgvProtocol.getRgvPosI2()); //更新小车当前位置站点号
//            WrkMastSta wrkMastSta = wrkMastStaMapper.selectNoInterfereToCrn(route, route, Long.valueOf(staProtocol.getWorkNo()));//根据站点工作号和小车工作范围检索任务档
//            if( null == wrkMastSta ) {
//                News.infoNoLog("" + mark + " - 1" + " - 4" + " - 查询无待入库数据--wrk_sts0, 工作号={}", staProtocol.getWorkNo());
//                continue;
//            }
//            WrkMastSta wrkMastSta1 = wrkMastStaMapper.selectByWrkNo( rgvProtocol.getTaskNo1());
//            boolean result = false;
//            if(wrkMastSta1!= null && rgvProtocol.getRgvNo() == 1){ //距离计算   2楼单入库口不需要计算
//                result = rgvCalcDistance((int) rgvProtocol.getRgvNo(),wrkMastSta1.getStaEnd(),wrkMastSta.getStaStart());//工位2放货站点，工位1取货站点
//            }
//            if(result){//若小车距离放货点距离近于取货点则跳过取货 true跳过取货/false优先取货
//                rgvThread.setPakRgv(false);
//                continue;
//            }
//            wrkMastSta.setWorkSta(wrkMastSta1 !=null ? 2 : 1);//若1号工位有任务给2号工位
//            wrkMastSta.setRgvNo((int) rgvProtocol.getRgvNo());
//            boolean sign = false;
//            sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta); //命令下发
//            if (sign){
    public synchronized void rgvRunWrkToCrn(RgvSlave slave, RgvProtocol rgvProtocol,Integer mark){
        for (RgvSlave.RgvStn rgvStn : slave.getRgvOutTStn()) {//rgv出库取货站点
            boolean flag = false;
            //遍历rgv入库取货站点
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, rgvStn.getDevpPlcId());
            StaProtocol staProtocol = devpThread.getStation().get(rgvStn.getStaNo());
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, (int) rgvProtocol.getRgvNo());
            BasRgv basRgv = basRgvService.selectById(slave.getId());
            if (basRgv == null) {
                log.error("{}号RGV尚未在数据库进行维护！4", slave.getId());
                continue;
            }
            StaProtocol staProtocol2 = null;
            WrkMastSta wrkMastSta3 = null;

            if(rgvStn.getStaNo2()!= null ){
                staProtocol2 = devpThread.getStation().get(rgvStn.getStaNo2());
                if (staProtocol2 == null) {
                    News.infoNoLog("" + mark + " - 1" + " - 1" + " - Rgv入库站信息(staProtocol!=null继续执行)：staProtocol=" + staProtocol);
                    continue;
                } else {
                    staProtocol2 = staProtocol2.clone();
                }
                BasDevp staDetl2 = basDevpService.selectById(rgvStn.getStaNo2());
                if (staDetl2 == null) {
                    News.error("" + mark + " - 1" + " - 2" + " - 入库 ===>>Rgv站点在数据库不存在, 站点编号={}", rgvStn.getStaNo());
                    continue;
                }
                wrkMastSta3 = wrkMastStaMapper.selectByWrkNo(staProtocol2.getWorkNo());

            }
            if (staProtocol == null) {
                News.infoNoLog("" + mark + " - 1" + " - 1" + " - Rgv出库站信息(staProtocol!=null继续执行)：staProtocol=" + staProtocol);
                continue;
            } else {
                staProtocol = staProtocol.clone();
            }

            // 查询站点详细信息
            BasDevp staDetl = basDevpService.selectById(rgvStn.getStaNo());
            if (staDetl == null) {
                News.error("" + mark + " - 1" + " - 2" + " - 出库 ===>>Rgv站点在数据库不存在, 站点编号={}", rgvStn.getStaNo());
                continue;
            }

            if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0
                    && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")) {
                flag = true;
            }
            if (!flag) {
                News.errorNoLog("" + mark + " - 1" + " - 3" + " - Rgv出库取货站信息(以下需要全true):"
                        + "自动信号" + staProtocol.isAutoing() + "有物信号" + staProtocol.isLoading()
                        + "工作号>0" + staProtocol.getWorkNo() + "可入信号" + staProtocol.isOutEnable()
                        + "能入信号（wms设置）.equals(\"Y\")" + staDetl.getCanouting());
                continue;
            }
            BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
            List<Integer> route = new ArrayList<>();
            switch (rgvProtocol.getRgvNo()){
                case 1: route = RouteUtils.getRouteOne();break;
                case 2: route = RouteUtils.getRouteTwo();break;
            }
            basRgvMap.setNowRoute(rgvProtocol.getRgvPosI2()); //更新小车当前位置站点号
            basRgvMapService.updateById(basRgvMap);
            WrkMastSta wrkMastSta = wrkMastStaMapper.selectNoInterfere(route, route, Long.valueOf(staProtocol.getWorkNo()));//根据站点工作号和小车工作范围检索任务档
            if( null == wrkMastSta ) {
                News.infoNoLog("" + mark + " - 1" + " - 4" + " - 查询无待入库数据--wrk_sts0, 工作号={}", staProtocol.getWorkNo());
                continue;
            }
            WrkMastSta wrkMastSta1 = wrkMastStaMapper.selectByWrkNo( rgvProtocol.getTaskNo1());
            if(basRgv.getPakToCrn().equals("0")){
                wrkMastSta = wrkMastStaMapper.selectNoInterfereCrn(route, route, Long.valueOf(staProtocol.getWorkNo()));
            }
            boolean result = false;
            if(wrkMastSta1!= null && rgvProtocol.getRgvNo() == 1){ //距离计算   2楼单入库口不需要计算
                result = rgvCalcDistance((int) rgvProtocol.getRgvNo(),wrkMastSta1.getStaEnd(),wrkMastSta.getStaStart());//工位2放货站点，工位1取货站点
            }
            if(result){//若小车距离放货点距离近于取货点则跳过取货 true跳过取货/false优先取货
                basRgv.setPakRgv("0");
                basRgvService.updateById(basRgv);

                continue;
            }
            wrkMastSta.setWorkSta(wrkMastSta1 !=null ? 2 : 1);//若1号工位有任务给2号工位
            wrkMastSta.setRgvNo((int) rgvProtocol.getRgvNo());
            boolean sign = false;
            sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta); //命令下发
            if (sign){
                if(LEFT_POSITION.contains(wrkMastSta.getStaEnd())){
                    basRgv.setPakToCrn("0");
                    basRgvService.updateById(basRgv);
                    if(wrkMastSta3 != null){
                        if(!LEFT_POSITION.contains(wrkMastSta3.getStaEnd())){
                            wrkMastSta3 = null;//若接驳第二位不接驳时取消连续取货
                        }
                    }
                }

                if(wrkMastSta3 != null ){
                    List<WrkMastSta> wrkMastStaPaking = wrkMastStaService.selectPakingWrk(wrkMastSta3.getStaStart());
                    if(wrkMastStaPaking.size() < 1){
                        wrkMastSta3.setMk(1);
                        basRgv.setPakAll("0");
                        basRgvService.updateById(basRgv);
                        try{
                            wrkMastStaMapper.updateById(wrkMastSta3);
                            log.error("锁定相隔站点任务");
                        }catch (Exception e){
                            log.error("锁定相隔站点任务失败");
                        }
                    }
                }
                basRgv.setPakIn("0");
                basRgvService.updateById(basRgv);

                rgvThread.setPaking(false);
//                rgvThread.setPakIn(false);//入库不允许
//                try{
//                    wrkMastSta.setWrkSts(1);
//                    wrkMastStaMapper.updateById(wrkMastSta);
//                    log.error("更新小车任务成功");
//                }catch (Exception e){
//                    log.error("更新小车任务失败");
//                }
//            } else {
//                log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
//            }
//
//
//        }
//    }
                try{
                    wrkMastSta.setWrkSts(1);
                    wrkMastStaMapper.updateById(wrkMastSta);
                    log.error("更新小车任务成功");
                }catch (Exception e){
                    log.error("更新小车任务失败");
                }
            } else {
                log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
            }


        }
    }
    /**
     * 执行小车搬运任务
     *
@@ -4257,9 +4498,20 @@
                                                .eq("status", 2)
                                                .eq("binding_tags", basArmMast.getBindingTags())
                                );

                                if (binding_tags<2){
                                    armTaskAssignmentCallApiLogSave(staProtocol, "条码数据已存在！！！", staProtocol.getSiteId()+"码垛位置，条码数据正在自动组托===>>" + barcode, false);
                                    continue;
                                    BasArmMast basArmMastOne = basArmMastService.selectOne(
                                            new EntityWrapper<BasArmMast>()
                                                    .eq("status", 2)
                                                    .eq("binding_tags", basArmMast.getBindingTags())
                                    );
                                    Double anfmeSignOne = basArmMastService.selectBasArmMastSignValue(basArmMastOne.getOrderNo(), basArmMastOne.getSku(),basArmMastOne.getBindingTags());

                                    if (anfmeSignOne>1D){
                                        armTaskAssignmentCallApiLogSave(staProtocol, "条码数据已存在！！！", staProtocol.getSiteId()+"码垛位置，条码数据正在自动组托===>>" + barcode, false);
                                        continue;
                                    }

                                }
                            }
                            OrderDetlValueResultUtil orderDetlValueResultUtil = basArmMastService.selectOrderDetlValue(basArmMast.getOrderNo(), basArmMast.getSku());
@@ -4310,13 +4562,374 @@
        }
    }

    public void armTaskAssignmentCallApiLogSave(StaProtocol staProtocol ,String tableName, String response, Boolean bool) {
        ApiLog apiLog = apiLogService.selectOne(new EntityWrapper<ApiLog>()
    public void armTaskAssignmentCallApiLogSave(StaProtocol staProtocol, String tableName, String response, Boolean bool) {
        // 查询符合条件的所有 ApiLog
        List<ApiLog> apiLogs = apiLogService.selectList(new EntityWrapper<ApiLog>()
                .eq("namespace", "机械臂任务相关")
                .eq("request", "站点号:" + staProtocol.getSiteId())
                .eq("response", response)
                .eq("url", tableName)
                .eq("client_ip", staProtocol.getBarcode())
                .eq("result", 0)
                .orderBy("create_time", false)
        );

        // 遍历结果集，检查时间戳差值是否小于 5 分钟
        for (ApiLog apiLog : apiLogs) {
            long parseLong = Long.parseLong(apiLog.getTimestamp());
            if (new Date().getTime() - parseLong < 5 * 1000 * 60) {
                // 如果找到符合条件的记录且时间差小于 5 分钟，则不保存新记录，直接返回
                return;
            }
        }

        // 如果没有符合条件的记录，或者所有记录时间差大于 5 分钟，保存新的日志
        apiLogService.save("机械臂任务相关", tableName, "null", staProtocol.getBarcode(),
                "站点号:" + staProtocol.getSiteId(),
                response, bool);
    }

    /*
     * agv任务生成  Full
     * */
    public synchronized void agvTaskCreateFull() {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历出库口
            for (DevpSlave.Sta outStaAgv : devp.getOutStaAgvFull())  {
                // 获取入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(outStaAgv.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                // 判断是否满足入库条件
                if (!staProtocol.isLoading()){
                    continue;
                }
                if (staProtocol.isAutoing() ) {
                    WrkMast wrkMast = wrkMastService.selectByWrkNo(staProtocol.getWorkNo());
                    if (Cools.isEmpty(wrkMast) || Cools.isEmpty(wrkMast.getTakeNone()) || !wrkMast.getTakeNone().equals("1")){
                        continue;
                    }

                    // 判断重复工作档
                    List<BasAgvMast> basAgvMastList = basAgvMastService.selectList(new EntityWrapper<BasAgvMast>().eq("task_no", staProtocol.getWorkNo()));
                    if (!basAgvMastList.isEmpty()) {
                        wrkMast.setTakeNone("2");
                        wrkMastMapper.updateById(wrkMast);
                        continue;
                    }

                    // 任务生成区 --------------------------------------------------------------------------

                    BasAgvMast basAgvMast = new BasAgvMast();


                    try {
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);

                        SearchLocParam param = new SearchLocParam();
                        param.setBarcode(wrkMast.getBarcode());
                        param.setIoType(1);
                        param.setSourceStaNo(outStaAgv.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/agv/loc/v1")
                                .setJson(JSON.toJSONString(param))
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                            basAgvMast.setTaskNo(wrkMast.getWrkNo());
                            basAgvMast.setSourceStaNo(outStaAgv.getStaNo());
                            basAgvMast.setLocNo(dto.getLocNo());
                            basAgvMast.setSourceLocNo(wrkMast.getSourceLocNo());
                            basAgvMast.setDevpId(devp.getId());
                            basAgvMast.setIoType(2);

                            basAgvMastService.insert(basAgvMast);


                            wrkMast.setTakeNone("2");
                            wrkMastMapper.updateById(wrkMast);
                        } else {
                            News.error(JSON.toJSONString(staProtocol));
                        }
                    } catch (Exception e) {
                        News.error(JSON.toJSONString(e.getMessage()));
                    }
                }
            }
        }
    }

    /*
     * agv任务生成  Empty
     * */
    public synchronized void agvTaskCreateEmpty() {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历出库口
            for (DevpSlave.Sta outStaAgv : devp.getOutStaAgvEmpty())  {
                // 获取入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(outStaAgv.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                // 判断是否满足入库条件
                if (!staProtocol.isLoading()){
                    continue;
                }

                String barcode = staProtocol.getBarcode();
                if(!Cools.isEmpty(barcode)) {
                    if("NG".endsWith(barcode) || "NoRead".equals(barcode)) {
                        News.info("{}号站点扫描器检测条码信息：{}", outStaAgv.getStaNo(), barcode);
                        continue;
                    }
                } else {
                    News.info("{}号站点扫描器检测条码信息：{}", outStaAgv.getStaNo(), barcode);
                    continue;
                }
                if (staProtocol.isAutoing()) {

                    // 判断重复工作档
                    List<BasAgvMast> basAgvMastList = basAgvMastService.selectList(new EntityWrapper<BasAgvMast>().eq("source_sta_no", outStaAgv.getStaNo()));
                    if (!basAgvMastList.isEmpty()) {
                        News.info("{}号站点存在任务执行中，请等待任务执行完毕：{}", outStaAgv.getStaNo(), barcode);
                        continue;
                    }

                    List<LocMast> locMastList = locMastService.selectList(new EntityWrapper<LocMast>().eq("barcode", barcode));
                    if (!locMastList.isEmpty()) {
                        News.info("{}号站点条码信息重复：{}", outStaAgv.getStaNo(), barcode);
                        continue;
                    }
                    // 任务生成区 --------------------------------------------------------------------------

                    BasAgvMast basAgvMast = new BasAgvMast();


                    try {
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);

                        SearchLocParam param = new SearchLocParam();
                        param.setBarcode(barcode);
                        param.setIoType(1);
                        param.setSourceStaNo(outStaAgv.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/agv/loc/v1")
                                .setJson(JSON.toJSONString(param))
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                            basAgvMast.setTaskNo(outStaAgv.getStaNo());
                            basAgvMast.setSourceStaNo(outStaAgv.getStaNo());
                            basAgvMast.setLocNo(dto.getLocNo());
                            basAgvMast.setDevpId(devp.getId());
                            basAgvMast.setIoType(2);

                            basAgvMastService.insert(basAgvMast);
                        } else {
                            News.error(JSON.toJSONString(staProtocol));
                        }
                    } catch (Exception e) {
                        News.error(JSON.toJSONString(e.getMessage()));
                    }
                }
            }
        }
    }


    /*
     * agv任务下发:AGV库位==》输送线站点
     * */
    public synchronized void agvTaskAssignment0() {
        try{
            List<BasAgvMast> basAgvMastList = basAgvMastService.selectList(new EntityWrapper<BasAgvMast>().eq("status", 0));
            for (BasAgvMast basAgvMast : basAgvMastList) {
                if (basAgvMast.getStatus()!=0 || basAgvMast.getIoType()!=0){//0==》AGV库位==》输送线站点
                    continue;
                }
                try{
                    // 获取站点信息
                    SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, basAgvMast.getDevpId());
                    StaProtocol staProtocol = devpThread.getStation().get(basAgvMast.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }

                    if (staProtocol.isAutoing()){

                        AgvTaskAssignmentParam agvTaskAssignmentParam = new AgvTaskAssignmentParam(basAgvMast);

                        //任务下发
                        ReturnT<String> result = new PostMesDataUtils().postMesDataAgv("AGV任务下发", AgvConstant.AGV_URL, AgvConstant.AGV_ADAPTOR, agvTaskAssignmentParam);
                        if (result.getCode()==200){
                            basAgvMast.setStatus(1);
                            basAgvMastService.updateById(basAgvMast);
                        } else {
                            agvTaskAssignmentCallApiLogSave(basAgvMast, "AGV任务下发失败", "任务号："+basAgvMast.getTaskNo()+"任务信息下发失败！！！", false);
                        }
                    }
                }  catch (Exception e){
                    log.error("任务号："+basAgvMast.getTaskNo()+"====》AGV任务下发失败"+e.getMessage());
                }
            }
        }catch (Exception e){
            log.error("AGV任务下发失败"+e.getMessage());
        }
    }

    /*
     * agv任务下发:AGV库位==》AGV库位
     * */
    public synchronized void agvTaskAssignment1() {
        try{
            List<BasAgvMast> basAgvMastList = basAgvMastService.selectList(new EntityWrapper<BasAgvMast>().eq("status", 0));
            for (BasAgvMast basAgvMast : basAgvMastList) {
                if (basAgvMast.getStatus()!=0 || basAgvMast.getIoType()!=1){//1==》AGV库位==》AGV库位
                    continue;
                }
                try{
                    AgvTaskAssignmentParam agvTaskAssignmentParam = new AgvTaskAssignmentParam(basAgvMast);

                    //任务下发
                    ReturnT<String> result = new PostMesDataUtils().postMesDataAgv("AGV任务下发", AgvConstant.AGV_URL, AgvConstant.AGV_ADAPTOR, agvTaskAssignmentParam);
                    if (result.getCode()==200){
                        basAgvMast.setStatus(1);
                        basAgvMastService.updateById(basAgvMast);
                    } else {
                        agvTaskAssignmentCallApiLogSave(basAgvMast, "AGV任务下发失败", "任务号："+basAgvMast.getTaskNo()+"任务信息下发失败！！！", false);
                    }

                }  catch (Exception e){
                    log.error("任务号："+basAgvMast.getTaskNo()+"====》AGV任务下发失败"+e.getMessage());
                }
            }
        }catch (Exception e){
            log.error("AGV任务下发失败"+e.getMessage());
        }
    }

    /*
     * agv任务下发:输送线站点==》AGV库位
     * */
    public synchronized void agvTaskAssignment2() {
        try{
            List<BasAgvMast> basAgvMastList = basAgvMastService.selectList(new EntityWrapper<BasAgvMast>().eq("status", 0));
            for (BasAgvMast basAgvMast : basAgvMastList) {
                if (basAgvMast.getStatus()!=0 || basAgvMast.getIoType()!=2){//2==》输送线站点==》AGV库位
                    continue;
                }
                try{
                    // 获取站点信息
                    SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, basAgvMast.getDevpId());
                    StaProtocol staProtocol = devpThread.getStation().get(basAgvMast.getSourceStaNo());
                    if (staProtocol == null || !staProtocol.isLoading()) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }

                    if ((!Cools.isEmpty(staProtocol.getWorkNo()) && staProtocol.getWorkNo().equals(basAgvMast.getTaskNo()))
                            ||
                            (basAgvMast.getSourceStaNo().equals(2033))){

                        AgvTaskAssignmentParam agvTaskAssignmentParam = new AgvTaskAssignmentParam(basAgvMast);

                        //任务下发
                        ReturnT<String> result = new PostMesDataUtils().postMesDataAgv("AGV任务下发", AgvConstant.AGV_URL, AgvConstant.AGV_ADAPTOR, agvTaskAssignmentParam);
                        if (result.getCode()==200){
                            basAgvMast.setStatus(1);
                            basAgvMastService.updateById(basAgvMast);
                        } else {
                            agvTaskAssignmentCallApiLogSave(basAgvMast, "AGV任务下发失败", "任务号："+basAgvMast.getTaskNo()+"任务信息下发失败！！！", false);
                        }
                    }
                }  catch (Exception e){
                    log.error("任务号："+basAgvMast.getTaskNo()+"====》AGV任务下发失败"+e.getMessage());
                }
            }
        }catch (Exception e){
            log.error("AGV任务下发失败"+e.getMessage());
        }
    }

    /*
     * agv任务下发:输送线站点==》输送线站点
     * */
    public synchronized void agvTaskAssignment3() {
        try{
            List<BasAgvMast> basAgvMastList = basAgvMastService.selectList(new EntityWrapper<BasAgvMast>().eq("status", 0));
            for (BasAgvMast basAgvMast : basAgvMastList) {
                if (basAgvMast.getStatus()!=0 || basAgvMast.getIoType()!=3){//3==》输送线站点==》输送线站点
                    continue;
                }
                try{
                    // 获取站点信息
                    SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, basAgvMast.getDevpId());
                    StaProtocol staProtocol = devpThread.getStation().get(basAgvMast.getSourceStaNo());
                    if (staProtocol == null || !staProtocol.isLoading()) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    // 获取站点信息
                    StaProtocol staProtocolEnd = devpThread.getStation().get(basAgvMast.getStaNo());
                    if (staProtocolEnd == null || !staProtocolEnd.isAutoing()) {
                        continue;
                    } else {
                        staProtocolEnd = staProtocolEnd.clone();
                    }

                    if (!Cools.isEmpty(staProtocol.getWorkNo()) && staProtocol.getWorkNo().equals(basAgvMast.getTaskNo())){

                        AgvTaskAssignmentParam agvTaskAssignmentParam = new AgvTaskAssignmentParam(basAgvMast);

                        //任务下发
                        ReturnT<String> result = new PostMesDataUtils().postMesDataAgv("AGV任务下发", AgvConstant.AGV_URL, AgvConstant.AGV_ADAPTOR, agvTaskAssignmentParam);
                        if (result.getCode()==200){
                            basAgvMast.setStatus(1);
                            basAgvMastService.updateById(basAgvMast);
                        } else {
                            agvTaskAssignmentCallApiLogSave(basAgvMast, "AGV任务下发失败", "任务号："+basAgvMast.getTaskNo()+"任务信息下发失败！！！", false);
                        }
                    }
                }  catch (Exception e){
                    log.error("任务号："+basAgvMast.getTaskNo()+"====》AGV任务下发失败"+e.getMessage());
                }
            }
        }catch (Exception e){
            log.error("AGV任务下发失败"+e.getMessage());
        }
    }

    public void agvTaskAssignmentCallApiLogSave(BasAgvMast basAgvMast ,String tableName, String response, Boolean bool) {
        ApiLog apiLog = apiLogService.selectOne(new EntityWrapper<ApiLog>()
                .eq("namespace", "Agv任务下发")
                .eq("request", "任务号:" + basAgvMast.getTaskNo())
                .eq("response", response)
                .eq("url", tableName)
                .eq("result", 0)
                .orderBy("create_time", false)
        );
@@ -4327,8 +4940,8 @@
                return;
            }
        }
        apiLogService.save("机械臂任务相关", tableName, "null", staProtocol.getBarcode(),
                "站点号:" + staProtocol.getSiteId() ,
        apiLogService.save("Agv任务下发", tableName, "null", "127.0.0.1",
                "任务号:" + basAgvMast.getTaskNo() ,
                response, bool);
    }