#空桶入库完成

zjj

2024-05-07 ab18ecb1c25613535c2047467cf8c14d3b41b047

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

@@ -24,21 +24,22 @@
import com.zy.common.utils.News;
import com.zy.core.CrnThread;
import com.zy.core.DevpThread;
import com.zy.core.RgvThread;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.*;
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.*;
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.SiemensDevpThread;
import com.zy.core.thread.ZyRgvThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
@@ -46,6 +47,7 @@
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

@@ -86,9 +88,13 @@
    private BasErrLogService basErrLogService;
    @Autowired
    private BasCrnErrorMapper basCrnErrorMapper;
    @Autowired
    private EmptyBarrelInService emptyBarrelInService;

    @Value("${wms.url}")
    private String wmsUrl;

    public int workNo = 9900;

    /**
     * 组托
@@ -106,10 +112,54 @@
                }
                String barcode = barcodeThread.getBarcode();

                ////判断101和104是否是拣料、并板、盘点再入库
                WrkMast wrkMast1=wrkMastMapper.selectpj(inSta.getStaNo(),barcode);
                if((inSta.getStaNo().equals(101) || inSta.getStaNo().equals(104)) &&!Cools.isEmpty(barcode)&&!Cools.isEmpty(wrkMast1)){
                    log.error("101或104拣料、并板、盘点再入库", wrkMast1.getWrkNo());


                // 获取入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                // 尺寸检测异常
                boolean back = false;
                String errMsg = "异常：";
                if (staProtocol.isFrontErr()) {
                    errMsg = errMsg+"前超限；";
                    back = true;
                }
                if (staProtocol.isBackErr()) {
                    errMsg = errMsg+"后超限";
                    back = true;
                }
                if (staProtocol.isHighErr()) {
                    errMsg = errMsg+"高超限";
                    back = true;
                }
                if (staProtocol.isLeftErr()) {
                    errMsg = errMsg+"左超限";
                    back = true;
                }
                if (staProtocol.isRightErr()) {
                    errMsg = errMsg+"右超限";
                    back = true;
                }
                if (staProtocol.isWeightErr()) {
                    errMsg = errMsg+"超重";
                    back = true;
                }
                if (staProtocol.isBarcodeErr()) {
                    errMsg = errMsg+"扫码失败";
                    back = true;
                }
                // 退回
                if (back) {
                    // led 异常显示
                    LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                    if (ledThread != null) {
                        MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
                    }
                    continue;
                }

@@ -127,24 +177,6 @@
//                    }
                    continue;
                }

                // 获取入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                // 入出库模式判断
                if (inSta.getStaNo() == 101 && devpThread.ioModeOf1F1 == IoModeType.PAKOUT_MODE) {
                    continue;
                }
                if (inSta.getStaNo() == 104 && devpThread.ioModeOf1F2 == IoModeType.PAKOUT_MODE) {
                    continue;
                }

                // 判断是否满足入库条件
                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
@@ -161,13 +193,13 @@
                            String errorMsg = "扫码失败，请重试";
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
                        }
                        staProtocol.setWorkNo((short)9999);
                        staProtocol.setStaNo((short)(staProtocol.getStaNo()-1));
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        if (!result) {
                            throw new CoolException("更新plc站点信息失败");
                        }
//                        staProtocol.setWorkNo((short)9999);
//                        staProtocol.setStaNo((short)(staProtocol.getStaNo()-1));
//                        devpThread.setPakMk(staProtocol.getSiteId(), false);
//                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                        if (!result) {
//                            throw new CoolException("更新plc站点信息失败");
//                        }
                        continue;
                    }

@@ -194,7 +226,6 @@
                        param.setIoType(1);
                        param.setSourceStaNo(inSta.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        param.setFull(staProtocol.isFull());
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/loc/v1")
@@ -216,11 +247,18 @@
                                throw new CoolException("更新plc站点信息失败");
                            }
                        } else if(jsonObject.getInteger("code").equals(700)) {
                            staProtocol.setWorkNo((short) 9999);
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                            staProtocol.setWorkNo((short) 9999);
//                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
//                            devpThread.setPakMk(staProtocol.getSiteId(), false);
//                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                            // led 异常显示
//                            if (ledThread != null) {
//                                String errorMsg = barcode + "托盘识别异常，请先进行组托！";
//                                MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
//                            }
                            log.error(barcode + "托盘识别异常，请先进行组托！");
                            // led 异常显示
                            ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                            if (ledThread != null) {
                                String errorMsg = barcode + "托盘识别异常，请先进行组托！";
                                MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
@@ -229,71 +267,11 @@
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                        }


//                        // 检索库位
//                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
//                        List<String> matNos = waitPakins.stream().map(WaitPakin::getMatnr).distinct().collect(Collectors.toList());
//                        StartupDto startupDto = commonService.getLocNo(1, 1, inSta.getStaNo(), matNos, locTypeDto, 0);
//                        // 工作号
//                        int workNo = startupDto.getWorkNo();
//                        // 插入工作明细档
//                        wrkDetlService.createWorkDetail(workNo, waitPakins, barcode);
//
//                        // 插入工作主档
//                        wrkMast = new WrkMast();
//                        wrkMast.setWrkNo(workNo);
//                        wrkMast.setIoTime(new Date());
//                        wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
//                        wrkMast.setIoType(1); // 入出库状态：1.入库
//                        wrkMast.setIoPri(10D); // 优先级：10
//                        wrkMast.setCrnNo(startupDto.getCrnNo());
//                        wrkMast.setSourceStaNo(startupDto.getSourceStaNo());
//                        wrkMast.setStaNo(startupDto.getStaNo());
//                        wrkMast.setLocNo(startupDto.getLocNo());
//                        wrkMast.setBarcode(barcode); // 托盘码
//                        wrkMast.setFullPlt("Y"); // 满板：Y
//                        wrkMast.setPicking("N"); // 拣料
//                        wrkMast.setExitMk("N"); // 退出
//                        wrkMast.setEmptyMk("N"); // 空板
//                        wrkMast.setLinkMis("N");
//                        // 操作人员数据
//                        wrkMast.setAppeTime(new Date());
//                        wrkMast.setModiTime(new Date());
//                        Integer insert = wrkMastMapper.insert(wrkMast);
//                        if (insert == 0) {
//                            throw new CoolException("保存工作档失败");
//                        }
//                        // 更新目标库位状态
//                        LocMast locMast = locMastService.selectById(startupDto.getLocNo());
//                        locMast.setLocSts("S"); // S.入库预约
//                        locMast.setModiTime(new Date());
//                        if (!locMastService.updateById(locMast)){
//                            throw new CoolException("改变库位状态失败");
//                        }
//                        // 将入库通知档修改为已启动
//                        if (wrkMastMapper.updateWaitPakInStep1(barcode) == 0) {
//                            throw new CoolException("修改入库通知档状态为已启动失败");
//                        }
//
//                        // 命令下发区 --------------------------------------------------------------------------
//
//                        // 更新站点信息 且 下发plc命令
//                        barcodeThread.setBarcode("");
//                        staProtocol.setWorkNo((short) workNo);
//                        staProtocol.setStaNo(startupDto.getStaNo().shortValue());
//                        devpThread.setPakMk(staProtocol.getSiteId(), false);
//                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                        if (!result) {
//                            throw new CoolException("更新plc站点信息失败");
//                        }

                    } catch (Exception e) {
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }

                }


            }
        }
@@ -397,7 +375,7 @@
                        && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && staProtocol.isPakMk()
                        && staProtocol.getWorkNo() == 9991) {
                        && staProtocol.getWorkNo() == 9999) {
//                    WrkMast wrkMast = wrkMastMapper.selectPickStep(barcode);
                    LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, pickSta.getLed());
                    if (barcode.equals("") || barcode.equals("99999999")) {
@@ -417,8 +395,9 @@
                        continue;
                    }

                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(staProtocol.getWorkNo().intValue());
                    ledThread.errorReset();
//                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(staProtocol.getWorkNo().intValue());
                    WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode", barcode));

                    if (wrkMast == null) {
                        wrkMast = wrkMastMapper.selectPickStep(barcode);
                    }
@@ -502,6 +481,8 @@
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (!result) {
                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    }else {
                        ledThread.errorReset();
                    }

                }
@@ -516,6 +497,9 @@
     */
    public synchronized void crnStnToOutStn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            if (crnSlave.getId() ==5){
                continue;
            }
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
                // 获取堆垛机出库站信息
@@ -549,16 +533,23 @@
                            && crnProtocol.forkPosType == CrnForkPosType.HOME) {

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

                        // 下发站点信息
                        staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                        staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                        if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                            continue;
                        if (crnProtocol.getCrnNo() !=5){
                            // 下发站点信息
                            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                            staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                            if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                                continue;
                            }
                        }

                        // 更新工作档状态为14失败
                        wrkMast.setWrkSts(14L);

                        if (crnStn.getStaNo() == 1016 || crnStn.getStaNo() == 1019) {
                            // 更新工作档状态为13.RGV搬运中
                            wrkMast.setWrkSts(13L);
                        }else {
                            // 更新工作档状态为14
                            wrkMast.setWrkSts(14L);
                        }
                        wrkMast.setCrnEndTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) != 0) {
                            // 复位堆垛机
@@ -579,6 +570,9 @@
     */
    public synchronized void crnIoExecute() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            if (crn.getId() == 5){
                continue;
            }
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
@@ -602,6 +596,9 @@
                // 如果最近一次是入库模式
                if (crnProtocol.getLastIo().equals("I")) {
                    if (basCrnp.getInEnable().equals("Y")) {
                        if (crn.getId() == 5){
                            continue;
                        }
                        this.crnStnToLoc(crn, crnProtocol); //  入库
                        crnProtocol.setLastIo("O");
                    } else if (basCrnp.getOutEnable().equals("Y")) {
@@ -615,6 +612,10 @@
                        this.locToCrnStn(crn, crnProtocol); //  出库
                        crnProtocol.setLastIo("I");
                    } else if (basCrnp.getInEnable().equals("Y")) {
                        if (crn.getId() == 5){
                            continue;
                        }

                        this.crnStnToLoc(crn, crnProtocol); //  入库
                        crnProtocol.setLastIo("O");
                    }
@@ -738,15 +739,6 @@
                continue;
            }

            //判断堆垛机和当前任务是否处于一个巷道
            if (Utils.getLaneByLocNo(wrkMast.getLocNo()) != crnProtocol.getCrnLane()) {
                //判断堆垛机所在巷道是否存在其他任务，如存在则优先执行
                List<WrkMast> wrkMasts = wrkMastService.selectLaneWrkMast(crnProtocol.getCrnLane(), true);
                if (!wrkMasts.isEmpty()) {
                    continue;//当前堆垛机所在巷道存在任务
                }
            }

            // 双深库位且浅库位有货，则需先对浅库位进行库位移转
            if (Utils.isDeepLoc(slaveProperties, wrkMast.getLocNo())) {
                String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getLocNo());
@@ -865,14 +857,6 @@
                    staProtocol = staProtocol.clone();
                }

//            // 入出库模式判断
                if (wrkMast.getStaNo() == 100 && devpThread.ioModeOf1F1 != IoModeType.PAKOUT_MODE) {
                    continue;
                }
                if (wrkMast.getStaNo() == 103 && devpThread.ioModeOf1F2 != IoModeType.PAKOUT_MODE) {
                    continue;
                }

                // 查询站点详细信息
                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                if (staDetl == null) {
@@ -897,7 +881,7 @@
                        LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                        // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！
                        if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
                            if (null == waitWrkMast) {
                                log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                            } else {
@@ -928,7 +912,7 @@
                            log.error("{}任务出库失败，浅库位堵塞！浅库位号:{}", wrkMast.getWrkNo(), shallowLocNo);
                            continue;
                        } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")) {
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(shallowLocNo);
                            if (null != waitWrkMast && (waitWrkMast.getWrkSts() == 4 || waitWrkMast.getWrkSts() == 5)) {
                                continue;
                            }
@@ -939,15 +923,6 @@
                    if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                        break;
//                        return;
                    }

                    //判断堆垛机和当前任务是否处于一个巷道
                    if (Utils.getLaneByLocNo(wrkMast.getLocNo()) != crnProtocol.getCrnLane()) {
                        //判断堆垛机所在巷道是否存在其他任务，如存在则优先执行
                        List<WrkMast> laneWrkMasts = wrkMastService.selectLaneWrkMast(crnProtocol.getCrnLane(), false);
                        if (!laneWrkMasts.isEmpty()) {
                            continue;//当前堆垛机所在巷道存在任务
                        }
                    }

                    // 1.堆垛机开始移动
@@ -1342,6 +1317,7 @@
                // 获取空板入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(emptyInSta.getStaNo());
                LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, emptyInSta.getLed());
                if (staProtocol == null) {
                    continue;
                } else {
@@ -1352,6 +1328,13 @@
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()
                        && staProtocol.isEmptyMk() && (staProtocol.getWorkNo() >= 9990
                        && staProtocol.getWorkNo() <= 9999) && staProtocol.isPakMk()) {
                    List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                            .eq("sta_no", emptyInSta.getStaNo())
                            .eq("io_type", 10)
                            .eq("wrk_sts", 2));
                    if (!Cools.isEmpty(wrkMasts)){
                        continue;
                    }
                    try {
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);

@@ -1368,7 +1351,7 @@
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                            ledThread.errorReset();
                            // 更新站点信息 且 下发plc命令
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());
@@ -1384,60 +1367,6 @@
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }


//                    // 检索库位
//                    LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
//                    StartupDto startupDto = commonService.getLocNo(1, 10, emptyInSta.getStaNo(), null, locTypeDto, 0);
//                    // 工作号
//                    int workNo = startupDto.getWorkNo();
//
//                    try {
//                        // 插入工作主档
//                        WrkMast wrkMast = new WrkMast();
//                        wrkMast.setWrkNo(workNo);
//                        wrkMast.setIoTime(new Date());
//                        wrkMast.setWrkSts(2L); // 工作状态：2.设备上走
//                        wrkMast.setIoType(10); // 入出库状态：10.空板入库
//                        wrkMast.setIoPri(10D); // 优先级：10
//                        wrkMast.setCrnNo(startupDto.getCrnNo());
//                        wrkMast.setSourceStaNo(startupDto.getSourceStaNo());
//                        wrkMast.setStaNo(startupDto.getStaNo());
//                        wrkMast.setLocNo(startupDto.getLocNo());
//                        wrkMast.setFullPlt("N"); // 满板
//                        wrkMast.setPicking("N"); // 拣料
//                        wrkMast.setExitMk("N"); // 退出
//                        wrkMast.setEmptyMk("Y"); // 空板
//                        wrkMast.setLinkMis("N");
////                    wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
//                        // 操作人员数据
//                        wrkMast.setAppeTime(new Date());
//                        wrkMast.setModiTime(new Date());
//                        Integer insert = wrkMastMapper.insert(wrkMast);
//                        if (insert == 0) {
//                            throw new CoolException("保存工作档失败");
//                        }
//                        // 更新目标库位状态
//                        LocMast locMast = locMastService.selectById(startupDto.getLocNo());
//                        locMast.setLocSts("S"); // S.入库预约
//                        locMast.setModiTime(new Date());
//                        if (!locMastService.updateById(locMast)){
//                            throw new CoolException("改变库位状态失败");
//                        }
//                        // 命令下发区 --------------------------------------------------------------------------
//
//                        // 更新站点信息 且 下发plc命令
//                        staProtocol.setWorkNo((short) workNo);
//                        staProtocol.setStaNo(startupDto.getStaNo().shortValue());
//                        devpThread.setPakMk(staProtocol.getSiteId(), false);
//                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                        if (!result) {
//                            throw new CoolException("更新plc站点信息失败");
//                        }
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                    }

                }

@@ -1563,7 +1492,7 @@
                // 获取叉车站点
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (staProtocol == null) { continue; }
                if (staProtocol.getWorkNo() != 0) {
                if (staProtocol.getWorkNo() != 0 || staProtocol.isErr()) {
                    reset = false;
                    break;
                }
@@ -2104,29 +2033,21 @@

    }

    public synchronized void outOfDevp() {
        List<WrkMast> wrkMasts = wrkMastMapper.selectPick();
        for (WrkMast wrkMast : wrkMasts) {
            if (basDevpService.selectCount(new EntityWrapper<BasDevp>().eq("wrk_no", wrkMast.getWrkNo())) == 0) {
                wrkMast.setCtnNo("Y");
                if (wrkMastMapper.updateById(wrkMast) == 0) {
                    log.error("修改{}工作档失败，ctn_no", wrkMast.getWrkNo());
                }
            }

        }
    }





    /**
     * 扫描碟盘机自动入库空托盘
     */
    public synchronized void autoEmptyIn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            // 遍历空板入库口
            for (CrnSlave.CrnStn emptyInStn : crnSlave.getEmptyCrnInStn()) {
        for (DevpSlave slave : slaveProperties.getDevp()) {
            for (DevpSlave.Sta sta : slave.getAutoEmptyIn()) {
                // 获取空板入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, emptyInStn.getDevpPlcId());
                StaProtocol staProtocol = devpThread.getStation().get(emptyInStn.getStaNo());
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, slave.getId());
                StaProtocol staProtocol = devpThread.getStation().get(sta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
@@ -2135,41 +2056,66 @@

                // 站点条件判断
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()
                        && staProtocol.isEmptyMk() && (staProtocol.getWorkNo() >= 9990
                        && staProtocol.getWorkNo() <= 9999)) {
                    try {
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
                        && staProtocol.isEmptyInPalletRequire() && staProtocol.getWorkNo() == 0) {
                    List<StaDesc> staDescs = staDescService.selectList(new EntityWrapper<StaDesc>().eq("type_no", 10).eq("stn_no", sta.getStaNo()));
                    for (StaDesc staDesc:staDescs){

                        SearchLocParam param = new SearchLocParam();
                        param.setIoType(10);
                        param.setSourceStaNo(emptyInStn.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/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);
                        BasDevp basDevp = basDevpService.selectOne(new EntityWrapper<BasDevp>().eq("dev_no", staDesc.getCrnStn()));

                            // 更新站点信息 且 下发plc命令
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());
                        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("crn_no", staDesc.getCrnNo()).gt("io_type", 100));
                        if (!Cools.isEmpty(wrkMast)){
                            continue;
                        }

                        if (basDevp.getAutoing().equals("Y") && basDevp.getLoading().equals("N")
                                && basDevp.getWrkNo() == 0 && basDevp.getCanining().equals("Y")){
//                             更新站点信息 且 下发plc命令
                            staProtocol.setWorkNo((short) 9997);
                            staProtocol.setStaNo(basDevp.getDevNo().shortValue());
//                            staProtocol.setStaNo((short) 1013);
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
                            if (!result) {
                                throw new CoolException("更新plc站点信息失败");
                            }
                        } else {
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                            return;
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

                    }


//                    try {
//                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
//
//                        SearchLocParam param = new SearchLocParam();
//                        param.setIoType(10);
//                        param.setSourceStaNo(sta.getStaNo());
//                        param.setLocType1(locTypeDto.getLocType1());
//                        String response = new HttpHandler.Builder()
//                                .setUri(wmsUrl)
//                                .setPath("/rpc/pakin/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);
//
//                            // 更新站点信息 且 下发plc命令
//                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
//                            staProtocol.setStaNo(dto.getStaNo().shortValue());
//                            devpThread.setPakMk(staProtocol.getSiteId(), false);
//                            boolean result = MessageQueue.offer(SlaveType.Devp, devpThread.getSlave().getId(), new Task(2, staProtocol));
//                            if (!result) {
//                                throw new CoolException("更新plc站点信息失败");
//                            }
//                        } else {
//                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
//                        }
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                    }
                }
            }
        }
@@ -2179,10 +2125,10 @@
     * 扫描拆盘机自动出库空托盘
     */
    public synchronized void autoEmptyOut() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            for (CrnSlave.CrnStn emptyOutStn : crnSlave.getEmptyCrnOutStn()) {
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, emptyOutStn.getDevpPlcId());
                StaProtocol staProtocol = devpThread.getStation().get(emptyOutStn.getStaNo());
        for (DevpSlave slave : slaveProperties.getDevp()) {
            for (DevpSlave.Sta sta : slave.getAutoEmptyOut()) {
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, slave.getId());
                StaProtocol staProtocol = devpThread.getStation().get(sta.getStaNo());
                if (staProtocol == null) {
                    return;
                } else {
@@ -2191,37 +2137,465 @@

                if (staProtocol.isAutoing()  //自动
                        && !staProtocol.isLoading()  //无物
                        && staProtocol.isOutEnable()  //可出信号
                        && staProtocol.isEmptyOutPalletRequire()  //空托盘需求信号
//                        && staProtocol.isEmptyMk()
                        && staProtocol.getWorkNo() == 0
                ) {
                    WrkMast pakoutEmpty = wrkMastMapper.selectPakoutEmpty(emptyOutStn.getStaNo());
                    WrkMast pakoutEmpty = wrkMastMapper.selectPakoutEmpty(sta.getStaNo());
                    if (null != pakoutEmpty) {
                        return;
                    }
                    try {
                        HashMap<String, Object> map = new HashMap<>();
                        map.put("crnNo", crnSlave.getId());
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setParams(map)
                                .setPath("/rpc/auto/emptyOut/v1")
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {
                            JSONObject data = (JSONObject) jsonObject.get("data");
                            log.info((String) data.get("msg"));
                        } else {
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/auto/emptyOut/v1","", response);
                    List<StaDesc> staDescs = staDescService.selectList(new EntityWrapper<StaDesc>().eq("stn_no", sta.getStaNo()));
                    for (StaDesc staDesc: staDescs){
                        BasCrnp basCrnp = basCrnpService.selectOne(new EntityWrapper<BasCrnp>().eq("crn_no", staDesc.getCrnNo()));
                        if (!basCrnp.getCrnSts().equals(3) || basCrnp.getCrnErr() != 0){
                            continue;
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        try {
                            HashMap<String, Object> map = new HashMap<>();
                            map.put("crnNo", staDesc.getCrnNo());//目标站
                            String response = new HttpHandler.Builder()
                                    .setUri(wmsUrl)
                                    .setParams(map)
                                    .setPath("/rpc/auto/emptyOut/v1")
                                    .build()
                                    .doPost();
                            JSONObject jsonObject = JSON.parseObject(response);
                            if (jsonObject.getInteger("code").equals(200)) {
                                JSONObject data = (JSONObject) jsonObject.get("data");
                                log.info((String) data.get("msg"));
                                return;
                            } else {
                                log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/auto/emptyOut/v1","", response);
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        }
                    }

                }
            }

        }

    }

    public synchronized void crn5InTask(){
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            if (crnSlave.getId() != 5){
                continue;
            }
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnSlave.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) {
                continue;
            }
            BasCrnp basCrnp = basCrnpService.selectById(crnSlave.getId());
            if (basCrnp == null) {
                log.error("{}号堆垛机尚未在数据库进行维护！", crnSlave.getId());
                continue;
            }
            // 只有当堆垛机空闲 并且 无任务时才继续执行
            if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO
                    && crnProtocol.getLoaded() == 0 && crnProtocol.getForkPos() == 0) {

//                Crn5InTaskSta(crnSlave,crnProtocol);

                // 如果最近一次是入库模式
                if (crnProtocol.getLastIo().equals("I")) {
                    if (basCrnp.getInEnable().equals("Y")) {
                        this.Crn5InTaskSta(crnSlave,crnProtocol);
                        crnProtocol.setLastIo("O");
                    } else if (basCrnp.getOutEnable().equals("Y")) {
                        this.locToCrn5Stn(crnSlave, crnProtocol); //  出库
                        crnProtocol.setLastIo("I");
                    }
                }
                // 如果最近一次是出库模式
                else if (crnProtocol.getLastIo().equals("O")) {
                    if (basCrnp.getOutEnable().equals("Y")) {
                        this.locToCrn5Stn(crnSlave, crnProtocol); //  出库
                        crnProtocol.setLastIo("I");
                    } else if (basCrnp.getInEnable().equals("Y")) {

                        this.Crn5InTaskSta(crnSlave,crnProtocol);
                        crnProtocol.setLastIo("O");
                    }
                }

            }

        }
    }
    public void Crn5InTaskSta(CrnSlave slave, CrnProtocol crnProtocol){
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            // 查询工作档
            WrkMast wrkMast = wrkMastMapper.selectCrn5Task2();
            if (wrkMast == null) {
                return;
            }
            // 获取库位信息
            LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
            if (locMast == null) {
                log.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
                return;
            }
            if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) {
                log.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
                return;
            }
            // 堆垛机控制过滤
            if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                return;
            }

            // 命令下发区 --------------------------------------------------------------------------
            CrnCommand crnCommand = new CrnCommand();
            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
            crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
            crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
            crnCommand.setSourcePosZ(crnStn.getLev().shortValue());     // 源库位层
            crnCommand.setDestinationPosX(locMast.getRow1()==9?(short)4:(short)5);     // 目标库位排
            crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
            crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
            crnCommand.setLocType1(locMast.getLocType1().shortValue());     // 货物类型
            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
            } else {
                // 修改工作档状态 2.设备上走 => 3.吊车入库中
                Date now = new Date();
                wrkMast.setWrkSts(3L);
                wrkMast.setCrnStrTime(now);
                wrkMast.setModiTime(now);
                if (wrkMastMapper.updateById(wrkMast) == 0) {
                    log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                }
            }
        }




    }


    public synchronized void crn5StnToOutStn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            if (crnSlave.getId() != 5){
                continue;
            }
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
                // 获取堆垛机出库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable()) {
                    // 查询工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(crnStn.getStaNo());
                    if (wrkMast == null) {
                        continue;
                    }
                    // 判断工作档条件
                    if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) {
                        continue;
                    }
                    // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                    CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkMast.getCrnNo());
                    CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                    if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) {
                        // 移动中
                        continue;
                    }
                    //  判断堆垛机状态等待确认
                    if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(wrkMast.getWrkNo().shortValue())
                            && crnProtocol.statusType == CrnStatusType.WAITING
                            && crnProtocol.forkPosType == CrnForkPosType.HOME) {

                            // 更新工作档状态为14
                            wrkMast.setWrkSts(14L);

                        wrkMast.setCrnEndTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) != 0) {
                            // 复位堆垛机
                            crnThread.setResetFlag(true);
                        } else {
                            log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                        }

                    }

                }
            }
        }
    }


    public synchronized void locToCrn5Stn(CrnSlave slave, CrnProtocol crnProtocol) {
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的出库工作档
//            WrkMast wrkMast = wrkMastMapper.selectPakOutStep1(slave.getId(), crnStn.getStaNo());
            List<WrkMast> wrkMasts = wrkMastMapper.selectPakOutStep11(slave.getId(), crnStn.getStaNo());
            //            获取工作状态为14的工作档
            WrkMast wrkMast1 = wrkMastMapper.selectPakOutStep14(slave.getId(), crnStn.getStaNo());
            if ( wrkMast1 !=null) {
                continue;
            }
            for (WrkMast wrkMast : wrkMasts) {
                if (wrkMast == null) {
                    continue;
                }
                // 工作档状态判断
                if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null) {
                    log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
                    continue;
                }
                // 获取源库位信息
                LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
                if (!locMast.getLocSts().equals("R") && !locMast.getLocSts().equals("P")) {
                    log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
                    continue;
                }
                // 获取堆垛机出库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                if (staProtocol == null) {
                    break;
//                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                // 查询站点详细信息
                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                if (staDetl == null) {
                    log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    break;
//                    continue;
                }
                // 判断堆垛机出库站状态
                if (staProtocol.isAutoing() && !staProtocol.isLoading() && staProtocol.isOutEnable()) {
                    // 命令下发区 --------------------------------------------------------------------------

                    // 堆垛机控制过滤
                    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(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(locMast.getRow1()==9?(short)4:(short)5);     // 源库位排
                    crnCommand.setSourcePosY(locMast.getBay1().shortValue());     // 源库位列
                    crnCommand.setSourcePosZ(locMast.getLev1().shortValue());     // 源库位层
                    crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                    crnCommand.setLocType1(locMast.getLocType1().shortValue());     // 货物类型
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                        log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                        Date now = new Date();
                        wrkMast.setWrkSts(12L);
                        wrkMast.setCrnStrTime(now);
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        break;
                    }
                }
            }
        }
    }

    public synchronized void crn5TaskCreate() throws IOException {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            if (crnSlave.getId() != 5){
                continue;
            }
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnInStn()) {
                // 获取堆垛机出库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                if (staProtocol == null) {
                    break;
//                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()){

                    EmptyBarrelIn emptyBarrelIn = emptyBarrelInService.selectOne(new EntityWrapper<>());
                    if (Cools.isEmpty(emptyBarrelIn)){
                        continue;
                    }

                    FullStoreParam fullStoreParam = new FullStoreParam();
                    fullStoreParam.setDevpNo(crnStn.getStaNo());
                    FullStoreParam.MatCodeStore matCodeStore = new FullStoreParam.MatCodeStore();
                    matCodeStore.setMatnr(emptyBarrelIn.getMatnr());
                    matCodeStore.setBatch(emptyBarrelIn.getBatch());
                    if (staProtocol.isForce()){
                        log.info("空桶强制入库："+staProtocol.getAmount());
                        matCodeStore.setAnfme(Double.valueOf(staProtocol.getAmount()));
                    }else {
                        matCodeStore.setAnfme(8d) ;
                    }
                    ArrayList<FullStoreParam.MatCodeStore> matCodeStores = new ArrayList<>();
                    matCodeStores.add(matCodeStore);
                    fullStoreParam.setList(matCodeStores);
                    try {
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/full/store/put/start")
                                .setJson(JSON.toJSONString(fullStoreParam))
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {
                            devpThread.setPakMk(crnStn.getStaNo(),false);
                        }
                    }catch (CoolException e){

                    }

                }

            }
        }
    }

    public synchronized void RGVTaskPut(){
        for (RgvSlave rgvSlave:slaveProperties.getRgv()){
            ZyRgvThread rgvThread = (ZyRgvThread)SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
            if (rgvProtocol.getModeType() != RgvModeType.AUTO){
                continue;
            }


            int workNo1 = 0;
            int workNo2 = 0;
            short souSta1 = 0;
            short sta1 = 0;
            short souSta2 = 0;
            short sta2 = 0;

            //工位一任务
            for (RgvSlave.Sta inStn :  rgvSlave.getInStn()){
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, inStn.getSourcePlcId());
                StaProtocol staProtocol = devpThread.getStation().get(inStn.getSourceStaNo());
                if (staProtocol == null) {
                    break;
//                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isLoading() && staProtocol.isLoading() && staProtocol.isInEnable()){
                    if (staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() <9900){
                        WrkMast wrkMast = wrkMastService.selectByworkNo(staProtocol.getWorkNo());
                        if (Cools.isEmpty(wrkMast)){
                            log.error("未找到工作档");
                            continue;
                        }
                        workNo1 = wrkMast.getWrkNo();
                        souSta1 = inStn.getSourceStaNo().shortValue();
                        sta1 = Utils.getRgvEndStaNo(rgvSlave.getId(),wrkMast.getStaNo());
                        break;
                    }
                    workNo1 = workNo++;
                    souSta1 = inStn.getSourceStaNo().shortValue();
                    sta1 = inStn.getStaNo().shortValue();
                    break;
                }
            }


            //工位二任务
            for (RgvSlave.Sta inStn :  rgvSlave.getInStn()){
                if (souSta1 == inStn.getSourceStaNo()){
                    continue;
                }
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, inStn.getSourcePlcId());
                StaProtocol staProtocol = devpThread.getStation().get(inStn.getSourceStaNo());
                if (staProtocol == null) {
                    break;
//                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isLoading() && staProtocol.isLoading() && staProtocol.isInEnable()){
                    if (staProtocol.getWorkNo() > 0 && staProtocol.getWorkNo() <9900){
                        WrkMast wrkMast = wrkMastService.selectByworkNo(staProtocol.getWorkNo());
                        if (Cools.isEmpty(wrkMast)){
                            log.error("未找到工作档");
                            continue;
                        }
                        workNo2 = wrkMast.getWrkNo();
                        souSta2 = inStn.getSourceStaNo().shortValue();
                        sta2 = Utils.getRgvEndStaNo(rgvSlave.getId(),wrkMast.getStaNo());
                        break;
                    }
                    workNo2 = workNo++;
                    souSta2 = inStn.getSourceStaNo().shortValue();
                    sta2 = inStn.getStaNo().shortValue();
                    break;
                }
            }

            //rgv任务下发--------------------------------------------------------------
            RgvCommand command = new RgvCommand();
            command.setRgvNo(rgvSlave.getId()); // RGV编号
            //工位1
            command.setTaskNo1(workNo1); // 工作号
            command.setSourceStaNo1(souSta1); // 源站
            command.setDestinationStaNo1(sta1);  // 目标站
            command.setAckFinish1(false);  // 任务完成确认位

            //工位2
            command.setTaskNo2(workNo2); // 工作号
            command.setSourceStaNo2(souSta2); // 源站
            command.setDestinationStaNo2(sta2);  // 目标站
            command.setAckFinish2(false);  // 任务完成确认位

            if (workNo1 != 0 && workNo2 ==0){
                command.setTaskMode(RgvTaskModeType.FETCH_PUT2); // 任务模式: 取放货
            } else if (workNo1 == 0 && workNo2 !=0) {
                command.setTaskMode(RgvTaskModeType.FETCH_PUT1); // 任务模式: 取放货
            }else {
                command.setTaskMode(RgvTaskModeType.FETCH_PUT_ALL); // 任务模式: 取放货
            }
            command.setCommand(false);
            MessageQueue.offer(SlaveType.Rgv, rgvSlave.getId(), new Task(2, command));
            log.info("rgv任务下发："+JSON.toJSONString(command));

        }
    }


    public synchronized void RGVTaskOver() {

    }
}