#

zjj

2024-11-03 4c0563ccd42cb718fa3868600287194497f2cf62

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

@@ -7,6 +7,7 @@
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.exception.CoolException;
import com.zy.asrs.domain.param.ForwardAGVTaskParam;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
@@ -26,17 +27,21 @@
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.*;
import com.zy.core.model.*;
import com.zy.core.enums.DevpType.DevpRequestType;
import com.zy.core.enums.DevpType.DevpStateType;
import com.zy.core.enums.DevpType.DevpTrayType;
import com.zy.core.enums.DevpType.DevpWorkType;
import com.zy.core.model.CrnSlave;
import com.zy.core.model.DevpSlave;
import com.zy.core.model.LedSlave;
import com.zy.core.model.Task;
import com.zy.core.model.command.CrnCommand;
import com.zy.core.model.command.LedCommand;
import com.zy.core.model.command.RgvCommand;
import com.zy.core.model.protocol.CrnProtocol;
import com.zy.core.model.protocol.RgvProtocol;
import com.zy.core.model.protocol.StaProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.BarcodeThread;
import com.zy.core.thread.LedThread;
import com.zy.core.thread.RgvThread;
import com.zy.core.thread.SiemensDevpThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -45,8 +50,9 @@
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
@@ -112,6 +118,7 @@
            for (DevpSlave.Sta inSta : devp.getInSta()) {
                // 获取条码扫描仪信息
                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
                BarcodeThread barcodeThreadMat = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcodeMat());
                LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
@@ -124,76 +131,20 @@
                if (barcodeThread == null) {
                    continue;
                }
                String barcode = barcodeThread.getBarcode();
                // 尺寸检测异常
                boolean back = false;
                String errMsg = "";
                if (staProtocol.isFrontErr()) {
                    errMsg = "前超限";
                    back = true;
                }
                if (!back && staProtocol.isBackErr()) {
                    errMsg = "后超限";
                    back = true;
                }
                if (!back && staProtocol.isHighErr()) {
                    errMsg = "高超限";
                    back = true;
                }
                if (!back && staProtocol.isLeftErr()) {
                    errMsg = "左超限";
                    back = true;
                }
                if (!back && staProtocol.isRightErr()) {
                    errMsg = "右超限";
                    back = true;
                }
                if (!back && staProtocol.isWeightErr()) {
                    errMsg = "超重";
                    back = true;
                }
                if (!back && staProtocol.isBarcodeErr()) {
                    errMsg = "扫码失败";
                    back = true;
                }
                // 退回
                if (back) {
//                        News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
                    MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));

                    if (!staProtocol.isLoading()){
                        continue;
                    }
                    if (!staProtocol.isPakMk()) {
                        continue;
                    }
                    staProtocol.setWorkNo(wrkNo);
                    News.info("{}入库回退：{}，任务号：{}", inSta.getStaNo(), errMsg,wrkNo);
                    wrkNo++;
                    staProtocol.setStaNo(inSta.getBackSta().shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    log.error("输送线下发1："+wrkNo+","+inSta.getBackSta());
                if (barcodeThreadMat == null) {
                    continue;
                }

                // 判断是否满足入库条件
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk()
                if (staProtocol.stateType == DevpStateType.AUTO //自动
                        && staProtocol.workType == DevpWorkType.BUSY //忙碌
                        && staProtocol.requestType == DevpRequestType.IN //可入
                        && staProtocol.trayType == DevpTrayType.FULL // 满板
                        && staProtocol.isPakMk()) {
                    if(Cools.isEmpty(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || "00000000".equals(barcode)) {
                        News.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);

                        staProtocol.setWorkNo(wrkNo);
                        News.info("{}入库回退：{}，任务号：{}", inSta.getStaNo(), errMsg,wrkNo);
                        wrkNo++;
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        log.error("输送线下发1："+wrkNo+","+inSta.getBackSta());
                        continue;
                    }
                    String barcode = staProtocol.getBarcode();

                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
                    if (wrkMast != null) {
@@ -233,7 +184,6 @@
                    }
                    try {
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);

                        SearchLocParam param = new SearchLocParam();
                        param.setBarcode(barcode);
                        param.setIoType(1);
@@ -263,7 +213,7 @@

                                throw new CoolException("更新plc站点信息失败");
                            }
                        } else {
                        }else {
                            staProtocol.setWorkNo(wrkNo);
                            wrkNo++;
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
@@ -312,17 +262,19 @@
                    staProtocol = staProtocol.clone();
                }

//                // 入出库模式判断
                // 入出库模式判断
                if (inSta.getStaNo() == 203 && devpThread.ioModeOf2F != IoModeType.PAKIN_MODE) {
                    continue;
                }

                // 判断是否满足入库条件
                if (!staProtocol.isLoading()){
                if (staProtocol.workType == DevpWorkType.BUSY){
                    continue;
                }
                if (staProtocol.isAutoing() && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk() && (staProtocol.getWorkNo() == 0 || staProtocol.getWorkNo() == 9999)
                if (staProtocol.stateType == DevpStateType.AUTO
                        && staProtocol.requestType == DevpRequestType.IN
                        && staProtocol.trayType == DevpTrayType.FULL
                        && (staProtocol.getWorkNo() == 0 || staProtocol.getWorkNo() == 9999)
                        && staProtocol.isPakMk()) {
                    News.warnNoLog(""+mark+" - 0"+" - 开始执行");
                    // 判断重复工作档
@@ -351,9 +303,9 @@
                    }

                }else {
                    News.errorNoLog(""+mark+" - 6"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.isLoading()+"、可入信号：" + staProtocol.isInEnable()
                            +"、空板信号："+ staProtocol.isEmptyMk()+"、工作号：" + staProtocol.getWorkNo()
                            +"、锁定标记"+ staProtocol.isPakMk()+"、入库印记：" + staProtocol.getStamp());
                    News.errorNoLog(""+mark+" - 6"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.stateType+"、可入信号：" + staProtocol.requestType
                            +"、空板信号："+ staProtocol.trayType+"、工作号：" + staProtocol.getWorkNo()
                            +"、锁定标记"+ staProtocol.isPakMk());
                }
            }
        }
@@ -395,8 +347,10 @@
//                // 入出库模式判断
//                if (devpThread.ioMode != IoModeType.PAKIN_MODE) { continue; }

                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()) {
                    News.warnNoLog(""+mark+" - 0"+" - 开始执行");
                if (staProtocol.stateType == DevpStateType.AUTO
                    && staProtocol.workType == DevpWorkType.BUSY
                    && staProtocol.requestType == DevpRequestType.IN
                    && staProtocol.isPakMk()) {
                    WrkMast wrkMast = wrkMastMapper.selectPickStep(barcode);
//                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(staProtocol.getWorkNo().intValue());
                    if (wrkMast == null) {
@@ -408,15 +362,6 @@
                        continue;
                    }

                    // 拣、盘、并 作业站转换
//                    int stnNo = 0;
//                    if (wrkMast.getStaNo() == 109) {
//                        stnNo = 127;
//                    } else if (wrkMast.getStaNo() == 113) {
//                        stnNo = 128;
//                    } else {
//                        log.error("{}号任务数据异常！", wrkMast.getWrkNo());
//                    }
                    // 获取目标站
                    Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                            .eq("type_no", wrkMast.getIoType() - 50)
@@ -482,7 +427,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());
@@ -491,8 +436,8 @@
                    }

                }else {
                    News.errorNoLog(""+mark+" - 6"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.isLoading()+"、可入信号：" + staProtocol.isInEnable()
                            +"、空板信号："+ staProtocol.isEmptyMk());
                    News.errorNoLog(""+mark+" - 6"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.stateType+"、可入信号：" + staProtocol.workType
                            +"、空板信号："+ staProtocol.trayType);
                }

            }
@@ -515,10 +460,10 @@
                } else {
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk()
                if (staProtocol.stateType == DevpStateType.AUTO
                        && staProtocol.workType == DevpWorkType.BUSY
                        && staProtocol.requestType == DevpRequestType.IN
                        && staProtocol.trayType == DevpTrayType.FULL
//                        && staProtocol.getWorkNo() > 0
                        && staProtocol.isPakMk()){

@@ -530,7 +475,7 @@
                    String barcode = barcodeThread.getBarcode();
                    if(!Cools.isEmpty(barcode)) {
//                        log.info("{}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
                        if("NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                        if("00000000".equals(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode) || "empty".equals(barcode)) {
                            staProtocol.setWorkNo(wrkNo++);
                            staProtocol.setStaNo(pickSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
@@ -620,7 +565,7 @@
                                log.info("任务号"+wrkMast.getWrkNo()+"盘点再入库查询库位成功===>>" + jsonObject.toJSONString());
                                try {
                                    // 更新站点信息 且 下发plc命令
                                    staProtocol.setWorkNo(wrkMast.getWrkNo());
                                    staProtocol.setWorkNo(dto.getWorkNo());
                                    staProtocol.setStaNo((short)161);
                                    devpThread.setPakMk(staProtocol.getSiteId(), false);

@@ -681,7 +626,7 @@
                } else {
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
//                if (staProtocol.stateType == DevpStateType.AUTO && staProtocol.workType == DevpWorkType.BUSY && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
                    // 查询工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(staProtocol.getSiteId());
                    if (wrkMast == null) {
@@ -702,7 +647,7 @@
                    if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(wrkMast.getWrkNo().shortValue())
                            && crnProtocol.statusType == CrnStatusType.WAITING
                            && crnProtocol.forkPosType == CrnForkPosType.HOME) {
                        News.error("堆垛机出库完成 - 开始执行");
                        log.info("堆垛机出库完成 - 开始执行");

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

@@ -710,7 +655,10 @@
                        staProtocol.setWorkNo(wrkMast.getWrkNo());
                        staProtocol.setStaNo(RouteUtils.CrnStaEnd(wrkMast.getStaNo(),wrkMast.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失败
@@ -718,7 +666,7 @@
                        wrkMast.setCrnEndTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) != 0) {
                            // 复位堆垛机
                            News.error("出库任务完成下发堆垛机复位", wrkMast.getWrkNo());
                            log.error("出库任务完成下发堆垛机复位,{}", wrkMast.getWrkNo());
                            crnThread.setResetFlag(true);
                        } else {
                            News.error(""+mark+" - 1"+" - 更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
@@ -732,7 +680,7 @@
                                +"、货叉位置："+crnProtocol.forkPosType+"==HOME：0  // 货叉原位：" + CrnForkPosType.HOME);
                    }

                }
//                }
            }
        }
//        News.infoNoLog(""+mark+" - 0"+" - 堆垛机站出库到出库站  ===》执行完成");
@@ -875,14 +823,14 @@
                News.error(""+mark+" - 1"+" - 2"+" - 入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                continue;
            }
            if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
            if ( staProtocol.stateType == DevpStateType.AUTO&& staProtocol.workType == DevpWorkType.BUSY&& staProtocol.getWorkNo() > 0 && staProtocol.requestType == DevpRequestType.IN
                    && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
                flag = true;
            }
            if (!flag) {
                News.errorNoLog(""+mark+" - 1"+" - 3"+" - 堆垛机入库站信息(以下需要全true):"
                        +"自动信号"+staProtocol.isAutoing()+"有物信号"+staProtocol.isLoading()
                        +"工作号>0"+staProtocol.getWorkNo()+"可入信号"+staProtocol.isInEnable()
                        +"自动信号"+staProtocol.stateType+"有物信号"+staProtocol.workType
                        +"工作号>0"+staProtocol.getWorkNo()+"可入信号"+staProtocol.requestType
                        +"能入信号（wms设置）.equals(\"Y\")"+staDetl.getCanining());
                continue;
            }
@@ -973,7 +921,7 @@
            crnCommand.setDestinationPosX(locMast.getRow1().shortValue());     // 目标库位排
            crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
            crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
            crnCommand.setTraySize(locMast.getLocType1() == 2);
            crnCommand.setTraySize(locMast.getLocType1());
            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                News.error(""+mark+" - 1"+" - 16"+" - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
            } else {
@@ -1054,8 +1002,8 @@
//                    continue;
                }
                // 判断堆垛机出库站状态
                if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
                        && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
                if (staProtocol.stateType == DevpStateType.AUTO && staProtocol.workType == DevpWorkType.IDLE && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
                        && staProtocol.getWorkNo() == 0 && staProtocol.requestType == DevpRequestType.OUT) {
                    // 命令下发区 --------------------------------------------------------------------------

                    // 堆垛机控制过滤
@@ -1135,7 +1083,7 @@
                    crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                    crnCommand.setTraySize(sourceSta.getLocType1() == 2);     //库位类型
                    crnCommand.setTraySize(sourceSta.getLocType1());     //库位类型
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                        News.error(""+mark+" - 2"+" - 13"+" - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
@@ -1334,7 +1282,7 @@
        crnCommand.setDestinationPosX(sta.getRow1().shortValue());     // 目标库位排
        crnCommand.setDestinationPosY(sta.getBay1().shortValue());     // 目标库位列
        crnCommand.setDestinationPosZ(sta.getLev1().shortValue());     // 目标库位层
        crnCommand.setTraySize(sourceSta.getLocType1() == 2);     //库位类型
        crnCommand.setTraySize(sourceSta.getLocType1());     //库位类型
        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
            News.error(""+mark+" - 3"+" - 4"+" - 堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
        } else {
@@ -1365,11 +1313,8 @@
            }
            //  状态：等待确认 并且  任务完成位 = 1
            if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
                News.warnNoLog(""+mark+" - 0"+" - 开始执行对工作档的完成操作");
                if (crnProtocol.getTaskNo() == 9999) {
                    // 堆垛机复位
                    crnThread.setResetFlag(true);
                } else {
                News.warnNoLog(""+mark+" - 0"+" - 开始执行对工作档的完成操作，任务号:"+crnProtocol.getTaskNo());

                    // 获取入库待确认工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue());
                    if (wrkMast == null) {
@@ -1388,12 +1333,13 @@
                    // 修改成功后复位堆垛机
                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        // 堆垛机复位
                        log.error(wrkMast.getWrkNo()+"任务修改状态4成功，复位堆垛机={}",crnThread.getCrnProtocol().getCrnNo());
                        News.warnNoLog(""+mark+" - 2"+" - 修改成功后复位堆垛机 : 堆垛机号={}",crnThread.getCrnProtocol().getCrnNo());
                        crnThread.setResetFlag(true);
                    }
                }

            }

        }
//        News.infoNoLog(""+mark+" - 0"+" - 对工作档的完成操作执行完成");
    }
@@ -1545,17 +1491,17 @@
                    ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, emptyInSta.getLed());
                }

                if (!staProtocol.isLoading()){
                if (staProtocol.workType == DevpWorkType.IDLE){
                    continue;
                }

                // 站点条件判断
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && staProtocol.isEmptyMk()
                if (staProtocol.stateType == DevpStateType.AUTO
                        && staProtocol.workType == DevpWorkType.BUSY
                        && staProtocol.requestType == DevpRequestType.IN
                        && staProtocol.trayType == DevpTrayType.EMPTY
                        && staProtocol.isPakMk()
                        && (staProtocol.getWorkNo() !=0 && staProtocol.getWorkNo() > 9700)
                        && ((staProtocol.getWorkNo() !=0 && staProtocol.getWorkNo() > 9700) || staProtocol.getSiteId() == 1025)
                        ) {
                    News.warnNoLog(""+mark+" - 0"+" - 开始执行：空栈板初始化入库,叉车入库站放货");

@@ -1578,7 +1524,7 @@

                            // 更新站点信息 且 下发plc命令
                            staProtocol.setWorkNo(dto.getWorkNo());
                            staProtocol.setStaNo(staProtocol.getSiteId().shortValue());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            log.error("输送线下发6："+dto.getWorkNo()+","+staProtocol.getSiteId());
@@ -1625,8 +1571,8 @@
                    }

                } else {
                    News.errorNoLog(""+mark+" - 4"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.isAutoing()+"、可入信号：" + staProtocol.isInEnable()
                            +"、空板信号："+ staProtocol.isEmptyMk()+"、工作号：" + staProtocol.getWorkNo()
                    News.errorNoLog(""+mark+" - 4"+" - 站点信息不符合入库条件！！！"+" 自动信号："+staProtocol.stateType+"、可入信号：" + staProtocol.workType
                            +"、空板信号："+ staProtocol.trayType+"、工作号：" + staProtocol.getWorkNo()
                            +"、锁定标记"+ staProtocol.isPakMk());
                }
            }
@@ -1648,7 +1594,7 @@
            for (Integer staNo : led.getStaArr()) {
                // 获取叉车站点
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (null == staProtocol || null == staProtocol.getWorkNo() || 0 == staProtocol.getWorkNo() || !staProtocol.isLoading()) {
                if (null == staProtocol || null == staProtocol.getWorkNo() || 0 == staProtocol.getWorkNo() || staProtocol.workType == DevpWorkType.IDLE) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
@@ -1766,13 +1712,13 @@
                // 获取叉车站点
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (staProtocol == null) { continue; }
                if (staProtocol.getWorkNo() != 0) {
                if (staProtocol.getWorkNo() != 0 || staProtocol.isErr()) {
                    reset = false;
                    break;
                }
            }
            // 获取led线程
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getDevpPlcId());
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
            // led显示默认内容
            if (reset) {
                if (ledThread == null) {
@@ -2138,68 +2084,7 @@
        }
    }

    /**
     * 入出库模式切换函数
     */
    public synchronized void ioConvert() {
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());

                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    if (inSta.getStaNo() == 2) {
                        continue;
                    }
                    WrkMast pakout = wrkMastMapper.selectWorkingPakout(inSta.getStaNo());
                    switch (inSta.getStaNo()) {
                        case 203://1F
                            if (pakout != null) {
                                if (devpThread.ioModeOf2F != IoModeType.PAKOUT_MODE) {
                                    // 出库切换中
                                    devpThread.ioModeOf2F = IoModeType.PAKOUT_BOOTING;
                                    WrkMast pakin = wrkMastMapper.selectWorkingPakin(inSta.getStaNo());
                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
                                            && !devpThread.getStation().get(inSta.getStaNo() + 1).isLoading()
                                            && devpThread.getStation().get(inSta.getStaNo() + 1).getWorkNo() == 0) {
                                        // 出库模式
                                        devpThread.ioModeOf2F = IoModeType.PAKOUT_MODE;
                                    }
                                }
                            } else {
                                // 入库模式
                                devpThread.ioModeOf2F = IoModeType.PAKIN_MODE;
                            }
                            break;
                        case 401://1F
                            if (pakout != null) {
                                if (devpThread.ioModeOf4F != IoModeType.PAKOUT_MODE) {
                                    // 出库切换中
                                    devpThread.ioModeOf4F = IoModeType.PAKOUT_BOOTING;
                                    WrkMast pakin = wrkMastMapper.selectWorkingPakin(inSta.getStaNo());
                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
                                            && !devpThread.getStation().get(inSta.getStaNo() + 1).isLoading()
                                            && devpThread.getStation().get(inSta.getStaNo() + 1).getWorkNo() == 0) {
                                        // 出库模式
                                        devpThread.ioModeOf4F = IoModeType.PAKOUT_MODE;
                                    }
                                }
                            } else {
                                // 入库模式
                                devpThread.ioModeOf4F = IoModeType.PAKIN_MODE;
                            }
                            break;
                    }
                }

            }

        } catch (Exception e) {
            e.printStackTrace();
        }


    }

    public synchronized void outOfDevp(Integer mark) {

@@ -2218,777 +2103,116 @@
//        News.infoNoLog(""+mark+" - 0"+" - outOfDevp执行完成");
    }


    public synchronized void autoEmptyOut() {
        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        List<Integer> list = new ArrayList<>();
        list.add(101);list.add(112);
        Map<Integer,Integer> map = new HashMap<>();
        map.put(101,102);map.put(112,111);
        for (Integer site:list){
            WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("sta_no", map.get(site)));
            if (!Cools.isEmpty(wrkMast)){
                continue;
            }
            //如果站点可出禁用，则不生成空盘出库任务
            StaProtocol staProtocol = devpThread.getStation().get(site);
            if (staProtocol == null) {
                return;
            } else {
                staProtocol = staProtocol.clone();
            }
            if (staProtocol.isAutoing()  //自动
                    && !staProtocol.isLoading()  //无物
                    && staProtocol.isOutEnable()  //可出信号
                    && staProtocol.getWorkNo() == 0
            ) {
                WrkMast pakoutEmpty = wrkMastMapper.selectPakoutEmpty(site);
                if (null != pakoutEmpty) {
                    return;
                }
                Short loctype1 = 1;
                if (site == 101){
                    loctype1 = 2;
                }
                LocTypeDto locTypeDto = new LocTypeDto(loctype1, (short) 1, (short) 1);
                locTypeDto.setSiteId(site);
                try {
                    String response = new HttpHandler.Builder()
                            .setUri(wmsUrl)
                            .setPath("/rpc/auto/emptyOut/v1")
                            .setJson(JSON.toJSONString(locTypeDto))
                            .build()
                            .doPost();
                    JSONObject jsonObject = JSON.parseObject(response);
                    if (jsonObject.getInteger("code").equals(200)) {
                        String data = jsonObject.get("data").toString();
                        News.info((String) jsonObject.get("msg")+","+data);
                    } else {
                        News.warnNoLog("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/auto/emptyOut/v1","", response);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                }
            }
        }

    }

    public synchronized void autoEmptyIn() {
        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        List<Integer> list = new ArrayList<>();
        list.add(153);list.add(157);
        for (Integer site:list){
            StaProtocol staProtocol = devpThread.getStation().get(site);
            if (staProtocol == null) {
                return;
            } else {
                staProtocol = staProtocol.clone();
            }
            if (staProtocol.isAutoing()  //自动
                    && staProtocol.isLoading()  //有物
                    && staProtocol.isInEnable()  //可入信号
                    && staProtocol.isPakMk()
                    && (staProtocol.getWorkNo() == 0 || staProtocol.getWorkNo() > 9990) //工作号为0或者工作号是9991~9999（输送机留用）
            ) {

                try {
                    Short loctype1 = 1;
                    if (site == 153){
                        loctype1 = 2;
                    }
                    LocTypeDto locTypeDto = new LocTypeDto(loctype1, (short) 1, (short) 1);
                    locTypeDto.setSiteId(site);

                    String response = new HttpHandler.Builder()
                            .setUri(wmsUrl)
                            .setPath("/rpc/auto/emptyIn/v1")
                            .setJson(JSON.toJSONString(locTypeDto))
                            .build()
                            .doPost();
                    JSONObject jsonObject = JSON.parseObject(response);
                    if (jsonObject.getInteger("code").equals(200)) {
                        News.info((String) jsonObject.get("msg"));
                        staProtocol.setWorkNo(jsonObject.get("data").hashCode());
                        staProtocol.setStaNo(site.shortValue());
                        devpThread.setPakMk(site,false);
                        MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
                    } else {
                        News.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/auto/emptyIn/v1", JSON.toJSONString(locTypeDto), response);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                }
            }

        }

    }

    /*
     * 小车地图更新  更新锁
     * */
    public synchronized boolean rgvMapUpdate(BasRgvMap basRgvMapCurrent,Integer staStart,Integer staEnd,String sign){

//        List<Integer> integers = RouteUtils.RouteMapCurrentFar(basRgvMapCurrent.getNowRoute(),staStart,staEnd, basRgvMapCurrent.getLockStartRoute());
        //更新当前小车锁
        try{
            Integer farCurrentStaNo = RouteUtils.RouteIndexFarMas(basRgvMapCurrent.getNowRoute(), staStart, staEnd, basRgvMapCurrent.getLockStartRoute());//获取最远站点
            Integer fallMerge = RouteUtils.RouteIndexFarMas(basRgvMapCurrent.getRgvNo(), farCurrentStaNo); //获取合并干涉项
            basRgvMapCurrent.setLockEndRoute(fallMerge);
            Integer i = basRgvMapMapper.updateById(basRgvMapCurrent);
//            if (i>0){
                log.error("{}:==>{}:{}号车更新结束锁,{}",sign,new Date(),basRgvMapCurrent.getRgvNo(),JSON.toJSONString(basRgvMapCurrent));
//            }

            //更新另一台小车地图
            Integer rgvNoOther = basRgvMapCurrent.getRgvNoOther(basRgvMapCurrent.getRgvNo());
            BasRgvMap basRgvMapOther = basRgvMapMapper.selectById(rgvNoOther);
            List<Integer> integers = RouteUtils.RouteMapCurrentFar(fallMerge, basRgvMapCurrent.getLockStartRoute());
            Integer lockEndRoute = RouteUtils.RouteMapOtherFarStnNo(integers, basRgvMapCurrent.getLockStartRoute());//另一台小车可活动最远位置
            basRgvMapOther.setEndRoute(lockEndRoute);
            Integer i1 = basRgvMapMapper.updateById(basRgvMapOther);
//            if (i1>0){
                log.error("{}:==>{}:{}号车更新结束位置,{}",sign,new Date(),basRgvMapOther.getRgvNo(),JSON.toJSONString(basRgvMapOther));
//            }
            return true;
        }catch (Exception e){
            log.error("小车地图更新出错！");
            return false;
        }
    }

    /*
     * 刷新地图数据
     * */
    public synchronized void refreshRgvMap() {
        try{
            List<BasRgvMap> basRgvMaps = basRgvMapService.selectList(new EntityWrapper<>());
            for (BasRgvMap rgvSlave:basRgvMaps) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
    public synchronized void forwardAGVInTasks() {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
            for (DevpSlave.Sta agvSta : devp.getAgvOutSta()) {
                // 获取入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(agvSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                }else {
                    rgvProtocol = rgvProtocol.clone();
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getRgvNo());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！2", rgvSlave.getRgvNo());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE &&
                    rgvProtocol.getModeType() == RgvModeType.AUTO
                    && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                    && (rgvProtocol.getTaskNo1()==0)
                        &&rgvThread.isPakMk()
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());

                    Integer rgvNoOther = basRgvMap.getRgvNoOther(rgvProtocol.getRgvNo());
                    RgvThread rgvThreadOther = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvNoOther);
                    RgvProtocol rgvProtocolOther = rgvThreadOther.getRgvProtocol();
                    if (rgvProtocolOther == null) {
                        continue;
                    }else {
                        rgvProtocolOther = rgvProtocolOther.clone();
                    }
                    if (rgvProtocolOther.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocolOther.getModeType() == RgvModeType.AUTO
                        && rgvProtocolOther.getLoaded1()==0
                        && (rgvProtocolOther.getTaskNo1()==0)
                        &&rgvThreadOther.isPakMk()
                    ){
                        //对工作档进行判断
                        basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                        if (rgvProtocol.getTaskNo1() >0 && rgvProtocol.getTaskNo1()<=9000){
                            WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo1().intValue());
                            rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd(),"2366");
                        }else if (rgvProtocol.getTaskNo1() == 0){
                            rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute(),"2366");
                        }

                    }



                }
            }
        }catch (Exception e){
            log.error("4109行执行小车初始化任务下发失败");
            log.error("4109行"+e);
        }
    }


    /**
     *  完成小车任务
     */
    public synchronized void rgvCompleteWrkMastSta() {
        try{
            for (DevpSlave devp : slaveProperties.getDevp()) {
                List<BasRgvMap> basRgvMaps = basRgvMapService.selectList(new EntityWrapper<>());
            for (BasRgvMap rgvSlave:basRgvMaps) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }else {
                    rgvProtocol = rgvProtocol.clone();
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getRgvNo());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！3", rgvSlave.getRgvNo());
                    continue;
                }

                // 只有当RGV等待WCS确认、自动
                if ((rgvProtocol.getStatusType1() == RgvStatusType.WAITING || rgvProtocol.getStatusType1()==RgvStatusType.FETCHWAITING)
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && (rgvProtocol.getStatusType() == RgvStatusType.WORKING1)
                ){
                    log.info("{}号小车等待wcs确认，状态{}，参数{}",rgvProtocol.getRgvNo(),rgvProtocol.getStatusType(),rgvProtocol);
                    if (rgvProtocol.getTaskNo1()!=0){
                        if (rgvProtocol.getTaskNo1()==32222){
                            boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
                            if (!rgvComplete){
                                log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            }
                            BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                            basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                            rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute(),"2415");
                            rgvThread.setPakMk(true);
                            break;
                        }
                        WrkMastSta wrkMastSta = wrkMastStaMapper.selectByWrkNo(rgvProtocol.getTaskNo1().intValue());
                        if (Cools.isEmpty(wrkMastSta) || wrkMastSta.getWrkSts()!=1){
                            log.error("未查到小车执行任务或者执行任务状态不符合！"+wrkMastSta);
                            continue;
                        }

                        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                        StaProtocol staProtocol = devpThread.getStation().get(wrkMastSta.getStaEnd());
                        if (staProtocol == null) {
                            continue;
                        } else {
                            staProtocol = staProtocol.clone();
                        }
                        if (!staProtocol.isAutoing() || !staProtocol.isLoading()){
                            continue;
                        }
                        WrkMast wrkMast = wrkMastMapper.selectPakInStep3(wrkMastSta.getWrkNo().intValue());
                        if (!Cools.isEmpty(wrkMast)){
                            if (!staProtocol.isPakMk()){
                                continue;
                            }
                            // 下发站点信息
                            staProtocol.setWorkNo(wrkMast.getWrkNo());
                            staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            log.error("rgv任务完成给输送线下发命令："+wrkMast.getWrkNo()+","+wrkMast.getStaNo());
                            if (!MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol))) {
                                continue;
                            }
                        }else {
                            log.error("rgv任务完成给输送线下发命令,但未查询到工作档");
                            // 下发站点信息
                            Map<Integer,Integer> map = new HashMap<>();
                            map.put(101,102);map.put(112,111);
                            map.put(100,100);
                            staProtocol.setWorkNo(rgvProtocol.getTaskNo1().intValue());
                            staProtocol.setStaNo(map.get(rgvProtocol.getRgvPosI()).shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
//                            log.error("rgv任务完成给输送线下发命令："+wrkMast.getWrkNo()+","+wrkMast.getStaNo());
                            if (!MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol))) {
                                continue;
                            }
                        }
                        boolean rgvComplete = rgvComplete(rgvProtocol.getRgvNo());
//                        boolean rgvComplete = true;
                        if (!rgvComplete){
                            log.error("小车复位失败，小车号{}！",rgvProtocol.getRgvNo());
                            break;
                        }
                        WrkMast wrkMast1 = wrkMastService.selectByWrkNo(rgvProtocol.getTaskNo1().intValue());
                        wrkMast1.setPdcType("Y");

                        wrkMastService.updateById(wrkMast1);

                        wrkMastSta.setWrkSts(3);
                        wrkMastStaMapper.updateById(wrkMastSta);
                        BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                        basRgvMap.setNowRoute(rgvProtocol.getRgvPosI());
                        rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute(),"2471");
                        rgvThread.setPakMk(true);
                    }

                    else {
                        log.error("小车复位失败，小车号{},等待wcs确认但是没有工作号！",rgvProtocol.getRgvNo());
                    }
                }
            }
            }
        }catch (Exception e){
            log.error("小车复位线程报错！"+e);
        }
    }
    /**
     * 执行小车搬运任务
     */
    public synchronized void rgvRunWrkMastFullSta() {
        boolean wrkEnable = false;
        try{
            List<BasRgvMap> basRgvMaps = basRgvMapService.selectList(new EntityWrapper<>());
            for (BasRgvMap rgvSlave:basRgvMaps) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }else {
                    rgvProtocol = rgvProtocol.clone();
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getRgvNo());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！4", rgvSlave.getRgvNo());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0
                        && rgvProtocol.getTaskNo1() == 0
                        && rgvThread.isPakMk()
                ) {
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (basRgvMap == null) {
                        log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
                        continue;
                    }
                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
                    List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);
                    for (WrkMastSta wrkMastSta : wrkMastStaList){
                        if (wrkMastSta.getType()!=0 || wrkMastSta.getWrkType()!=3){//1:满版   3：取放
                            continue;
                        }
                        boolean sign = rgvTakeFullAll(basRgvMap.getRgvNo(), wrkMastSta); //命令下发
                        wrkEnable = true;
                        if (sign){
                            rgvThread.setPakMk(false);
                            boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), wrkMastSta.getStaEnd(),"2526");
                            if (signMap){
                                Thread.sleep(300);
                                wrkMastSta.setWrkSts(1);
                                try{
                                    wrkMastStaMapper.updateById(wrkMastSta);
                                    return;
                                }catch (Exception e){
                                    log.error("更新小车任务失败");
                                }
                                break;
                            }else {
                                log.error("3864行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
                            }
                        } else {
                            log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
                        }
                        break;
                    }
                }

            }
            if (!wrkEnable){
                rgvRunWrkMastEmptyStaAvoidance();
            }
        }catch (Exception e){
            log.error("3875行执行小车搬运任务下发失败");
            log.error("3875行"+e);
        }
    }
    /**
     * 执行小车搬运任务
     */
//    public synchronized void rgvRunWrkMastEmptyStaPut() {//放
//        try{
//            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
//                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
//                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
//                if (rgvProtocol == null) {
//                    continue;
//                }
//                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
//                if (basRgv == null) {
//                    log.error("{}号RGV尚未在数据库进行维护！5", rgvSlave.getId());
//                    continue;
//                }
//
//                // 只有当RGV空闲、自动,工位二有物//rgv可用
//                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
//                        && rgvProtocol.getModeType() == RgvModeType.AUTO
//                        && rgvProtocol.getLoaded1()==1  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
//                ) {
//                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
//                    if (basRgvMap == null) {
//                        log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
//                        continue;
//                    }
//                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
//                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());//获取活动范围
//                    List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);//查询可执行任务
//                    for (WrkMastSta wrkMastSta : wrkMastStaList){
//                        if (wrkMastSta.getType()!=2 || (wrkMastSta.getWrkType()!=2 && wrkMastSta.getWrkType()!=4)){// 2:空板  2:放 4：拆盘
//                            continue;
//                        }
//                        boolean sign = false;
//                        if (wrkMastSta.getStaStart()==0 && wrkMastSta.getStaEnd()!=0){//放
//                            sign = rgvPutEmpty(rgvProtocol.getRgvNo(),wrkMastSta);
//                        }else {
//                            continue;
//                        }
//                        if (sign){
//                            boolean signMap = rgvMapUpdate(basRgvMap, basRgvMap.getStartRoute(), wrkMastSta.getStaEnd());
//                            if (signMap){
//                                wrkMastSta.setWrkSts(2);
//                                try{
//                                    wrkMastStaMapper.updateById(wrkMastSta);
//                                }catch (Exception e){
//                                    log.error("更新小车任务失败");
//                                }
//                                return;
//                            }else {
//                                log.error("3857行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
//                            }
//                        }else {
//                            log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
//                        }
//                        break;
//                    }
//                }
//            }
//        }catch (Exception e){
//            log.error("3933行执行小车放空板任务下发失败");
//            log.error("3933行"+e);
//        }
//    }

//    public synchronized void rgvRunWrkMastEmptyStaTake() {//取
//        try{
//            for (RgvSlave rgvSlave:slaveProperties.getRgv()) {
//                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
//                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
//                if (rgvProtocol == null) {
//                    continue;
//                }
//                BasRgv basRgv = basRgvService.selectById(rgvSlave.getId());
//                if (basRgv == null) {
//                    log.error("{}号RGV尚未在数据库进行维护！6", rgvSlave.getId());
//                    continue;
//                }
//
//                // 只有当RGV空闲、自动,工位二无物//rgv可用
//                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
//                        && rgvProtocol.getModeType() == RgvModeType.AUTO
//                        && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
//                ) {
//                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
//                    if (basRgvMap == null) {
//                        log.error("{}号RGV尚未在数据库地图中进行维护！", rgvProtocol.getRgvNo());
//                        continue;
//                    }
//                    List<Integer> route = RouteUtils.getRoute(basRgvMap.getStartRoute(), basRgvMap.getEndRoute());
//                    basRgvMap.setNowRoute(rgvProtocol.getRgvPosI()); //更新小车当前位置站点号
//                    List<WrkMastSta> wrkMastStaList = wrkMastStaMapper.selectNoInterfereList(route, route);
//                    for (WrkMastSta wrkMastSta : wrkMastStaList){
//                        if (wrkMastSta.getType()!=2 || wrkMastSta.getWrkType()!=1){// 2:空板  1:取
//                            continue;
//                        }
//                        boolean sign = false;
//                        if (wrkMastSta.getStaEnd()==0 && wrkMastSta.getStaStart()!=0){//取
//                            sign = rgvTakeEmpty(rgvProtocol.getRgvNo(),wrkMastSta);
//                        } else {
//                            continue;
//                        }
//                        if (sign){
//                            boolean signMap = rgvMapUpdate(basRgvMap, wrkMastSta.getStaStart(), basRgvMap.getStartRoute());
//                            if (signMap){
//                                wrkMastSta.setWrkSts(1);
//                                try{
//                                    wrkMastStaMapper.updateById(wrkMastSta);
//                                }catch (Exception e){
//                                    log.error("更新小车任务失败");
//                                }
//                                return;
//                            }else {
//                                log.error("3879行，货物搬运任务：工作号{}所属任务下发后地图同步失败",wrkMastSta.getWrkNo());
//                            }
//                        }else {
//                            log.error("工作号{}所属任务下发失败",wrkMastSta.getWrkNo());
//                        }
//                        break;
//                    }
//                }
//            }
//        }catch (Exception e){
//            log.error("3989行执行小车取空板任务下发失败");
//            log.error("3989行"+e);
//        }
//    }

    /*
     * 有任务但未执行  此时需要调整小车位置
     * */
    public synchronized void rgvRunWrkMastEmptyStaAvoidance() {
        try{
            Integer integer = wrkMastStaMapper.selectAllWrkStsCount(null,0);//查询状态为0的任务
            if (integer==0){
                return;
            }
            List<BasRgvMap> basRgvMaps = basRgvMapService.selectList(new EntityWrapper<>());
            for (BasRgvMap rgvSlave:basRgvMaps) {
                RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getRgvNo());
                RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
                if (rgvProtocol == null) {
                    continue;
                }else {
                    rgvProtocol = rgvProtocol.clone();
                }
                BasRgv basRgv = basRgvService.selectById(rgvSlave.getRgvNo());
                if (basRgv == null) {
                    log.error("{}号RGV尚未在数据库进行维护！1", rgvSlave.getRgvNo());
                    continue;
                }

                // 只有当RGV空闲、自动,工位一无物//rgv可用
                if (rgvProtocol.getStatusType() == RgvStatusType.IDLE
                        && rgvProtocol.getModeType() == RgvModeType.AUTO
                        && rgvProtocol.getLoaded1()==0  //现场修改：叠盘机，不满都算无物，怎么判断需要跟电控对接
                        && rgvProtocol.getTaskNo1()==0
                        && rgvProtocol.getStatusType1() == RgvStatusType.IDLE
                        && rgvThread.isPakMk()
//                        && rgvProtocol.getTaskNo2()==0
                ){
                    BasRgvMap basRgvMap = basRgvMapMapper.selectById(rgvProtocol.getRgvNo());
                    if (rgvProtocol.getRgvPosI().equals(basRgvMap.getStartRoute())){
                        continue;
                    }
//                    if (rgvProtocol.getRgvNo()==1 && rgvProtocol.getRgvPosI().equals(100)){
//                        continue;
//                    } else if (rgvProtocol.getRgvNo()==2 && rgvProtocol.getRgvPosI().equals(157)  ){
//                        continue;
//                    }
                    rgvAvoidanceXY(rgvProtocol.getRgvNo());
                    rgvMapUpdate(basRgvMap,basRgvMap.getStartRoute(),basRgvMap.getStartRoute(),"2727");
                }
            }
        }catch (Exception e){
            log.error("4109行执行小车初始化任务下发失败");
            log.error("4109行"+e);
        }
    }

    /*
     * 小车XY移动  避让
     * */
    public synchronized boolean rgvAvoidanceXY(Integer rgvId){
        BasRgvMap basRgvMap = basRgvMapService.selectByRgvNo(rgvId);
        if (basRgvMap.getStartRoute() == 100 || basRgvMap.getStartRoute() == 101){
            try{

                //  命令下发区 --------------------------------------------------------------------------
                RgvCommand rgvCommand = new RgvCommand();
                rgvCommand.setRgvNo(rgvId); // RGV编号
                rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                rgvCommand.setTaskNo1((short)32222); // 工位1工作号
                rgvCommand.setTaskMode1(RgvTaskModeType.X_MOVE); // 工位1任务模式:  回原点
                //basRgvMap.getLockStartRoute().shortValue()
                rgvCommand.setSourceStaNo1(basRgvMap.getStartRoute().shortValue());
                rgvCommand.setCommand((short) 1);   //工位1任务确认
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                    return false;
                } else {
                    return true;
                    staProtocol = staProtocol.clone();
                }
            }catch (Exception e){
                return false;

            }
        }else {
            try{
                //  命令下发区 --------------------------------------------------------------------------
                RgvCommand rgvCommand = new RgvCommand();
                rgvCommand.setRgvNo(rgvId); // RGV编号
                rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
                rgvCommand.setTaskNo1((short)32222); // 工位1工作号
                rgvCommand.setTaskMode1(RgvTaskModeType.X_MOVE); // 工位1任务模式:  回原点
                //basRgvMap.getLockStartRoute().shortValue()
                rgvCommand.setSourceStaNo1(basRgvMap.getStartRoute().shortValue());
                rgvCommand.setCommand((short) 1);   //工位1任务确认
                if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                    //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务   step=9，回原点 9999任务号
                    log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                    return false;
                } else {
                    return true;
                if (!(staProtocol.stateType == DevpStateType.AUTO && staProtocol.requestType == DevpRequestType.OUT)){
                    continue;
                }
            }catch (Exception e){
                return false;
                if (staProtocol.getWorkNo() == 0){
                    continue;
                }
                WrkMast wrkMast1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", staProtocol.getWorkNo()).eq("wrk_sts", 101));
                if(!Cools.isEmpty(wrkMast1)){
                    continue;
                }
                //查询状态为2的任务
                //查询状态为2的任务
                WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                        .eq("wrk_no", staProtocol.getWorkNo())
                        .in("io_type",101,110,103,104,107)
                        .eq("wrk_sts", 15));
                if (Cools.isEmpty(wrkMast)) {
                    log.error(agvSta.getStaNo()+"站,转发agv任务未找到对应任务,任务号："+staProtocol.getWorkNo());
                    continue;
                }
                ForwardAGVTaskParam forwardAGVTaskParam = new ForwardAGVTaskParam();
                getAgvTaskParam(forwardAGVTaskParam,wrkMast,staProtocol.getSiteId());
                String request = forwardAGVHttpRequest(forwardAGVTaskParam, "10.0.100.110:8182", "/rcms/services/rest/hikRpcService/genAgvSchedulingTask");
                if ("SUCCESS".equals(request)) {
                    wrkMast.setWrkSts(101L);
                    boolean update = wrkMastService.updateById(wrkMast);
                    if (update){
                        log.info("入库转发AGV任务完成,任务号:"+wrkMast.getWrkNo());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                    }
                }



            }
        }

    }

    private void getAgvTaskParam(ForwardAGVTaskParam agvTaskCreateParam,WrkMast param,Integer staNo){
        String sourceSite = "";
        if (staNo == 1040 || staNo == 1042) {
            sourceSite = "a";
        } else if (staNo == 2010 || staNo == 2012) {
            sourceSite = "b";
        } else if(staNo == 3010  || staNo ==3012) {
            sourceSite = "c";
        } else if(staNo == 2000 || staNo ==2002) {
            sourceSite = "d";
        }
        List<ForwardAGVTaskParam.PositionCodePaths> agvTaskParamList = Arrays.asList(
                //起始位
                new ForwardAGVTaskParam.PositionCodePaths(staNo.toString(),"05"),
                //目标位
                new ForwardAGVTaskParam.PositionCodePaths(sourceSite,"04")
        );
        Date date = new Date();
        DecimalFormat df = new DecimalFormat("0000");
        String wrkNo = "Crn"+df.format(param.getWrkNo())+date.getTime()/1000;
        agvTaskCreateParam.setReqCode(wrkNo);
        agvTaskCreateParam.setReqTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        agvTaskCreateParam.setTaskTyp("GT4");
        agvTaskCreateParam.setCtnrCode(param.getBarcode());
        agvTaskCreateParam.setPositionCodePath(agvTaskParamList);
        agvTaskCreateParam.setCtnrTyp("2");
        agvTaskCreateParam.setPriority("1");
        agvTaskCreateParam.setTaskCode(wrkNo);

    /*
     * 小车取货至工位任务
     * */
    public synchronized boolean rgvTakeFullAll(Integer rgvId,WrkMastSta wrkMastSta){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            RgvCommand rgvCommand = new RgvCommand();
            rgvCommand.setRgvNo(rgvId); // RGV编号
            rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
            rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().shortValue()); // 工位1工作号
            rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 工位1任务模式:  取放货
            rgvCommand.setSourceStaNo1(wrkMastSta.getStaStart().shortValue());   //工位1起点
            rgvCommand.setDestinationStaNo1(wrkMastSta.getStaEnd().shortValue());   //工位1目标站点
            rgvCommand.setCommand((short) 1);   //工位1任务确认
            if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
                return false;
            } else {
                return true;
    }

    private String forwardAGVHttpRequest(Object requestParam, String url, String path){
        String response = "";
        String success = "error";
        try {
            response = new HttpHandler.Builder()
                    .setUri(url)
//                    .setHttps(true)
                    .setPath(path)
                    .setJson(JSONObject.toJSONString(requestParam))
                    .build()
                    .doPost();
            JSONObject jsonObject = JSON.parseObject(response);

            String message = jsonObject.get("code").toString();
            if(("0").equals(message) || ("请求编号已存在").contains(message)){
                success = "SUCCESS";
            }else {
                success = message;
            }
            log.info("转发agv任务：请求体:"+JSONObject.toJSONString(requestParam)+",返回值:"+jsonObject);
        }catch (Exception e){
            return false;

        }
        return success;
    }

    /*
     * 小车取货至工位任务
     * */
//    public synchronized boolean rgvTakeFull(Integer rgvId,WrkMastSta wrkMastSta){
//        try{
//            //  命令下发区 --------------------------------------------------------------------------
//            RgvCommand rgvCommand = new RgvCommand();
//            rgvCommand.setRgvNo(rgvId); // RGV编号
//            rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
//            rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().shortValue()); // 工位1工作号
//            rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 工位1任务模式:  取货
//            rgvCommand.setSourceStaNo1(wrkMastSta.getStaStart().shortValue());   //工位1起点
//            rgvCommand.setCommand((short) 1);   //工位1任务确认
//            if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
//                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
//                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
//                return false;
//            } else {
//                return true;
//            }
//        }catch (Exception e){
//            return false;
//        }
//    }

    /*
     * 小车放货至输送线任务
     * */
//    public synchronized boolean rgvPutFull(Integer rgvId,WrkMastSta wrkMastSta){
//        try{
//            //  命令下发区 --------------------------------------------------------------------------
//            RgvCommand rgvCommand = new RgvCommand();
//            rgvCommand.setRgvNo(rgvId); // RGV编号
//            rgvCommand.setAckFinish1((short) 0);  // 工位1任务完成确认位
//            rgvCommand.setTaskNo1(wrkMastSta.getWrkNo().shortValue()); // 工位1工作号
//            rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 工位1任务模式:  放货
//            rgvCommand.setDestinationStaNo1(wrkMastSta.getStaEnd().shortValue());   //工位1目标站点
//            rgvCommand.setCommand((short) 1);   //工位1任务确认
//            if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(4, rgvCommand))) {
//                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
//                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
//                return false;
//            } else {
//                return true;
//            }
//        }catch (Exception e){
//            return false;
//        }
//    }

    /*
     * 小车取空板至工位任务
     * */
//    public synchronized boolean rgvTakeEmpty(Integer rgvId,WrkMastSta wrkMastSta){
//        try{
//            //  命令下发区 --------------------------------------------------------------------------
//            RgvCommand rgvCommand = new RgvCommand();
//            rgvCommand.setRgvNo(rgvId); // RGV编号
//            rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
//            rgvCommand.setTaskNo2(wrkMastSta.getWrkNo().shortValue()); // 工位2工作号
//            rgvCommand.setTaskMode2(RgvTaskModeType.FETCH); // 工位2任务模式:  取货
//            rgvCommand.setSourceStaNo2(wrkMastSta.getStaStart().shortValue());   //工位2起点
//            rgvCommand.setCommand((short) 2);   //工位2任务确认
//            if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(5, rgvCommand))) {
//                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
//                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
//                return false;
//            } else {
//                return true;
//            }
//        }catch (Exception e){
//            return false;
//        }
//    }

    /*
     * 小车放空板至输送线任务
     * */
//    public synchronized boolean rgvPutEmpty(Integer rgvId,WrkMastSta wrkMastSta){
//        try{
//            //  命令下发区 --------------------------------------------------------------------------
//            RgvCommand rgvCommand = new RgvCommand();
//            rgvCommand.setRgvNo(rgvId); // RGV编号
//            rgvCommand.setAckFinish2((short) 0);  // 工位2任务完成确认位
//            rgvCommand.setTaskNo2(wrkMastSta.getWrkNo().shortValue()); // 工位2工作号
//            rgvCommand.setTaskMode2(RgvTaskModeType.PUT); // 工位2任务模式:  放货
//            rgvCommand.setDestinationStaNo2(wrkMastSta.getStaEnd().shortValue());   //工位2目标站点
//            rgvCommand.setCommand((short) 2);   //工位2任务确认
//            if (!MessageQueue.offer(SlaveType.Crn, rgvId, new Task(5, rgvCommand))) {
//                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
//                log.error("RGV命令下发失败，RGV号={}，任务数据={}", rgvId, JSON.toJSON(rgvCommand));
//                return false;
//            } else {
//                return true;
//            }
//        }catch (Exception e){
//            return false;
//        }
//    }

    /*
     * 小车复位
     * */
    public synchronized boolean rgvComplete(Integer rgvId){
        try{
            //  命令下发区 --------------------------------------------------------------------------
            if (!MessageQueue.offer(SlaveType.Rgv, rgvId, new Task(3, new RgvCommand()))) {
                //step=2,工位1、2写任务；   step=4，工位1写任务；     step=5，工位2写任务
                log.error("RGV命令下发失败，RGV号={}",rgvId);
                return false;
            } else {
                log.info("RGV命令下发成功，RGV号={}",rgvId);
                return true;
            }
        }catch (Exception e){
            log.error("RGV命令下发失败，RGV号={}。异常："+e,rgvId);
            return false;
        }
    }

}