Merge remote-tracking branch 'origin/jxtlfwcs' into jxtlfwcs

野心家

2025-06-19 020f48adb61a0350924783c1b397bd381d20ddc8

 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.enums.WorkNoType;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.BasCrnErrorMapper;
import com.zy.asrs.mapper.TestMastMapper;
@@ -19,6 +20,7 @@
import com.zy.common.service.CommonService;
import com.zy.common.utils.CollectionUtils;
import com.zy.common.utils.HttpHandler;
import com.zy.common.utils.News;
import com.zy.core.CrnThread;
import com.zy.core.DevpThread;
import com.zy.core.cache.MessageQueue;
@@ -38,18 +40,18 @@
import com.zy.core.thread.SiemensCrnThread;
import com.zy.core.thread.SiemensDevpThread;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import springfox.documentation.spring.web.json.Json;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.*;
import java.util.stream.Collectors;


/**
 * 立体仓库WCS系统主流程业务
@@ -94,6 +96,8 @@

    @Value("${test.url}")
    private String testUrl;
    @Autowired
    private WrkMastService wrkMastService;

    /**
     * 组托
@@ -104,76 +108,87 @@
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
            for (DevpSlave.Sta inSta : devp.getInSta()) {
                inSta.setStaNo(102);
                // 获取条码扫描仪信息
                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
                if (barcodeThread == null) {
                    continue;
                }
                String barcode = barcodeThread.getBarcode();
//                barcode="ILY0127 0001";
                if(!Cools.isEmpty(barcode)) {
                    log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
                    if("NG".endsWith(barcode) || "NoRead".equals(barcode)) {
                        continue;
                    }
                } else {
                    continue;
                }

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

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

                // 判断是否满足入库条件
                Short workNo = staProtocol.getWorkNo();
                // 尺寸检测异常
                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;
                }
                //9991满托，9990空托
                String barcode = barcodeThread.getBarcode();
                if (staProtocol.isAutoing() && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk() && (staProtocol.getWorkNo() == 0 || staProtocol.getWorkNo() == 9999)
                        && staProtocol.isPakMk()){// && !Cools.isEmpty(barcode)) {
                        && !staProtocol.isEmptyMk() && (staProtocol.getWorkNo() >= 9990 && staProtocol.getWorkNo() <= 9999)
                        && staProtocol.isPakMk()) {// && !Cools.isEmpty(barcode)) {

//                    if(Cools.isEmpty(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode)) {
//                        log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
//                        //条码为空或者不符合，退库到172站点
//                        staProtocol.setWorkNo((short)9999);
//                        staProtocol.setStaNo((short)172);
//                        devpThread.setPakMk(staProtocol.getSiteId(), false);
//                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                        if (!result) {
//                            throw new CoolException("更新plc站点信息失败");
//                        }
//                        continue;
//                    }

                    // 退回
                    if (back || (!Cools.isEmpty(barcode) && barcode.equals("00000000"))) {
                        staProtocol.setWorkNo((short) 9999);
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                        // led 异常显示
                        LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
                        if (ledThread != null) {
                            MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errMsg));
                        }
                        continue;
                    }

                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
                    if (wrkMast != null) {
                        log.error("工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={}", wrkMast.getWrkNo());
                        News.error("工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={}", wrkMast.getWrkNo());
                        continue;
                    }
//                    // 获取入库通知档
//                    List<WaitPakin> waitPakins = waitPakinMapper.selectList(new EntityWrapper<WaitPakin>().eq("zpallet", barcode).eq("io_status", "N"));
//                    if (waitPakins.isEmpty()) {
//                        log.error("无此入库条码数据。条码号={}", barcode);
//                        continue;
//                    }

                    try {

                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
                        locTypeDto.setLocType1((short)1);
                        locTypeDto.setLocType1((short) 1);
                        SearchLocParam param = new SearchLocParam();
                        param.setBarcode(barcode);
                        param.setIoType(1);
                        param.setSourceStaNo(inSta.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        log.info("满板入库={}",param);
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/loc/v1")
@@ -183,92 +198,34 @@
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
                            staProtocol.setStaNo(dto.getStaNo().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
                                News.error("更新plc站点信息失败");
                                throw new CoolException("更新plc站点信息失败");
                            }
                        } else if (jsonObject.getInteger("code").equals(700) && (!barcodeThread.getBarcode().equals("NG"))){
                        } else if (jsonObject.getInteger("code").equals(700) && (!barcodeThread.getBarcode().equals("NG"))) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);
                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo((short)9998);
                            staProtocol.setStaNo((short)101);
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            staProtocol.setWorkNo((short) 9991);
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), true);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            log.error("url：{}；request：{}；response：{}", wmsUrl+"/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                        }else {
                            News.error("url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                        } else {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);
                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo((short)9998);
                            staProtocol.setStaNo((short)101);
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            staProtocol.setWorkNo((short) 9991);
                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
                            devpThread.setPakMk(staProtocol.getSiteId(), true);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                            News.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) {
                        News.error("扫码入库报错，错误信息", e);
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }
@@ -308,7 +265,9 @@
                        && staProtocol.isPakMk()) {
                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep11(inSta.getStaNo());
                    if (wrkMast == null) { continue; }
                    if (wrkMast == null) {
                        continue;
                    }

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

@@ -325,7 +284,7 @@
                            log.error("更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
                        }
                    } else {
                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                        News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    }

                }
@@ -339,7 +298,7 @@
    /**
     * 拣料、并板、盘点再入库
     */
    public synchronized void stnToCrnStnPick(){
    public synchronized void stnToCrnStnPick() {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历拣料入库口
            for (DevpSlave.Sta pickSta : devp.getPickSta()) {
@@ -349,9 +308,9 @@
                    continue;
                }
                String barcode = barcodeThread.getBarcode();
                if(!Cools.isEmpty(barcode)) {
                if (!Cools.isEmpty(barcode)) {
                    log.info("{}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
                    if("NG".endsWith(barcode) || "NoRead".equals(barcode)) {
                    if ("NG".endsWith(barcode) || "NoRead".equals(barcode)) {
                        continue;
                    }
                } else {
@@ -370,7 +329,7 @@
//                // 入出库模式判断
//                if (devpThread.ioMode != IoModeType.PAKIN_MODE) { continue; }

                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()){
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()) {

//                    if(Cools.isEmpty(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode)) {
//                        log.info("{}号条码扫描器检测条码信息：{}", pickSta.getBarcode(), barcode);
@@ -391,7 +350,7 @@
                        continue;
                    }
                    if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107)
                        || Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo()) ) {
                            || Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo())) {
                        continue;
                    }

@@ -487,7 +446,7 @@
                } else {
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isAutoing() && (staProtocol.isLoading()||staProtocol.getSiteId()==109) && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
                if (staProtocol.isAutoing() && (staProtocol.isLoading() || staProtocol.getSiteId() == 1000) && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
                    // 查询工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakOutStep2(staProtocol.getSiteId());
                    if (wrkMast == null) {
@@ -495,6 +454,7 @@
                    }
                    // 判断工作档条件
                    if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) {
                        News.error("工作档案条件不满足：工作档案：" + wrkMast + ";条件iotype<100或者staNo为空或者sourceStaNo为空");
                        continue;
                    }
                    // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
@@ -525,7 +485,7 @@
                            // 复位堆垛机
                            crnThread.setResetFlag(true);
                        } else {
                            log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                            News.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                        }

                    }
@@ -538,15 +498,17 @@
    /**
     * 入出库  ===>>  堆垛机入出库作业下发
     */
    public synchronized void crnIoExecute(){
    public synchronized void crnIoExecute() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }
            if (crnProtocol == null) {
                continue;
            }
            BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
            if (basCrnp == null) {
                log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
                News.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
                continue;
            }

@@ -559,7 +521,7 @@
            if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO
                    && crnProtocol.getLoaded() == 0 && crnProtocol.getForkPos() == 0) {
                // 库位移转
                this.stnToStn(crn, crnProtocol);
//                this.stnToStn(crn, crnProtocol);
                // 如果最近一次是入库模式
                if (crnProtocol.getLastIo().equals("I")) {
                    if (basCrnp.getInEnable().equals("Y")) {
@@ -591,7 +553,7 @@
    /**
     * 回原点，堆垛机没有执行中任务，设备存在入库任务时叫回原点
     */
    public synchronized void crnRebackHp(CrnProtocol crnProtocol, CrnThread crnThread){
    public synchronized void crnRebackHp(CrnProtocol crnProtocol, CrnThread crnThread) {
//        for (CrnSlave crn : slaveProperties.getCrn()) {
//            // 获取堆垛机信息
//            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
@@ -604,51 +566,51 @@
//                log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
//                continue;
//            }
            if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                if(crnProtocol.getBay() ==1 && crnProtocol.getLevel()==1){
                    return;
                }

                // 已经存在吊车执行任务时，则过滤3,12
                if (wrkMastMapper.selectWorking(crnProtocol.getCrnNo()) != null) {
                    return;
                }

                //堆垛机有执行中任务，过滤3,4,11,12
                if (wrkMastMapper.selectCrnWorking(crnProtocol.getCrnNo()) != null) {
                    return;
                }

                //输送线没有入库任务，过滤2
                if (wrkMastMapper.selectDevWorking(crnProtocol.getCrnNo()) == null) {
                    return;
                }

                log.info("堆垛机召回原点==>>" + crnProtocol.getCrnNo() + "号堆垛机有入库任务,召回原点");
                // 命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo((short) 9999); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.GO_ORIGIN); // 任务模式:  回原点
                crnCommand.setSourcePosX((short) 0);     // 源库位排
                crnCommand.setSourcePosY((short) 0);     // 源库位列
                crnCommand.setSourcePosZ((short) 0);     // 源库位层
                crnCommand.setDestinationPosX((short) 0);     // 目标库位排
                crnCommand.setDestinationPosY((short) 0);     // 目标库位列
                crnCommand.setDestinationPosZ((short) 0);     // 目标库位层
                if (!MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, crnCommand))) {
                    log.error("堆垛机回原点命令下发失败，堆垛机号={}，任务数据={}", crnProtocol.getCrnNo(), JSON.toJSON(crnCommand));
                }
                crnThread.setBackHpFlag(true);
        if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
            if (crnProtocol.getBay() == 1 && crnProtocol.getLevel() == 1) {
                return;
            }

            // 已经存在吊车执行任务时，则过滤3,12
            if (wrkMastMapper.selectWorking(crnProtocol.getCrnNo()) != null) {
                return;
            }

            //堆垛机有执行中任务，过滤3,4,11,12
            if (wrkMastMapper.selectCrnWorking(crnProtocol.getCrnNo()) != null) {
                return;
            }

            //输送线没有入库任务，过滤2
            if (wrkMastMapper.selectDevWorking(crnProtocol.getCrnNo()) == null) {
                return;
            }

            log.info("堆垛机召回原点==>>" + crnProtocol.getCrnNo() + "号堆垛机有入库任务,召回原点");
            // 命令下发区 --------------------------------------------------------------------------
            CrnCommand crnCommand = new CrnCommand();
            crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
            crnCommand.setTaskNo((short) 9999); // 工作号
            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
            crnCommand.setTaskMode(CrnTaskModeType.GO_ORIGIN); // 任务模式:  回原点
            crnCommand.setSourcePosX((short) 0);     // 源库位排
            crnCommand.setSourcePosY((short) 0);     // 源库位列
            crnCommand.setSourcePosZ((short) 0);     // 源库位层
            crnCommand.setDestinationPosX((short) 0);     // 目标库位排
            crnCommand.setDestinationPosY((short) 0);     // 目标库位列
            crnCommand.setDestinationPosZ((short) 0);     // 目标库位层
            if (!MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, crnCommand))) {
                log.error("堆垛机回原点命令下发失败，堆垛机号={}，任务数据={}", crnProtocol.getCrnNo(), JSON.toJSON(crnCommand));
            }
            crnThread.setBackHpFlag(true);
        }
//        }
    }

    /**
     * 入库  ===>>  堆垛机站到库位
     */
    public void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol){
    public void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol) {
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            boolean flag = false;
            // 获取堆垛机入库站信息
@@ -662,11 +624,11 @@
            // 查询站点详细信息
            BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
            if (staDetl == null) {
                log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                News.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                continue;
            }
            if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
                    && staDetl.getCanining()!=null && staDetl.getCanining().equals("Y")) {
                    && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
                flag = true;
            }
            if (!flag) {
@@ -674,18 +636,18 @@
            }
            // 获取工作状态为2（设备上走）的入库工作档
            WrkMast wrkMast = wrkMastMapper.selectPakInStep2(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo());
            if(null == wrkMast) {
            if (null == wrkMast) {
//                log.error("查询无待入库数据--wrk_sts=2, 工作号={}", staProtocol.getWorkNo());
                continue;
            }
            // 获取库位信息
            LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
            if (locMast == null) {
                log.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
                News.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
                continue;
            }
            if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) {
                log.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
                News.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
                continue;
            }

@@ -707,12 +669,12 @@
                if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                    WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                    if (null == waitWrkMast) {
                        log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                        News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                    } else {
                        waitWrkMast.setIoPri(15D);
                        waitWrkMast.setModiTime(new Date());
                        if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                            log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                            News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                        }
                        continue;
                    }
@@ -729,9 +691,9 @@
//                        moveLocForDeepLocPakin(slave, shallowLoc, wrkMast);
                    }
                    continue;
                } else if (shallowLoc.getLocSts().equals("Q")){
                } else if (shallowLoc.getLocSts().equals("Q")) {
                    WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                    if (null != waitWrkMast && waitWrkMast.getWrkSts()==4) {
                    if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
                        continue;
                    }
                }
@@ -748,10 +710,14 @@
            crnCommand.setSourcePosZ(crnStn.getLev().shortValue());     // 源库位层
            crnCommand.setDestinationPosX(locMast.getRow1().shortValue());     // 目标库位排
            crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
            crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
            crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层\
            crnCommand.setBarcode(wrkMast.getBarcode());//托盘码
            log.error("768 堆垛机命令下发" + crnCommand);
            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
            } else {
                log.error("772 堆垛机命令下发成功" + crnCommand);
                News.info("772 堆垛机命令下发成功" + crnCommand);

//                long startTime = System.currentTimeMillis();
//                while ((System.currentTimeMillis() - startTime) < COMMAND_TIMEOUT) {
@@ -766,13 +732,17 @@
//                }

                // 修改工作档状态 2.设备上走 => 3.吊车入库中
                log.error("787 修改工作档状态2.设备上走 => 3.吊车入库中 " + wrkMast);
                News.info("787 修改工作档状态2.设备上走 => 3.吊车入库中 " + wrkMast);
                Date now = new Date();
                wrkMast.setWrkSts(3L);
                wrkMast.setCrnStrTime(now);
                wrkMast.setModiTime(now);
                if (wrkMastMapper.updateById(wrkMast) == 0) {
                    log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                    News.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                }
                log.error("795 修改工作档状态成功2.设备上走 => 3.吊车入库中" + wrkMast);
                News.info("795 修改工作档状态成功2.设备上走 => 3.吊车入库中" + wrkMast);
            }
        }
    }
@@ -781,24 +751,24 @@
     * 出库  ===>>  库位到堆垛机站
     * 2022-06-09 TQS修改，查询工作档LIST，遍历下发，防止第一个任务堵塞出库
     */
    public void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
    public void locToCrnStn(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());
            for (WrkMast wrkMast : wrkMasts){
            for (WrkMast wrkMast : wrkMasts) {
                if (wrkMast == null) {
                    continue;
                }
                // 工作档状态判断
                if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null){
                    log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
                if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null) {
                    News.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
                    continue;
                }
                // 获取源库位信息
                LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
                if (!sourceSta.getLocSts().equals("R") &&!sourceSta.getLocSts().equals("P")) {
                    log.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
                if (!sourceSta.getLocSts().equals("R") && !sourceSta.getLocSts().equals("P")) {
                    News.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
                    continue;
                }
                // 获取堆垛机出库站信息
@@ -811,18 +781,24 @@
                    staProtocol = staProtocol.clone();
                }

//            // 入出库模式判断
//            if (devpThread.ioMode != IoModeType.PAKOUT_MODE) { continue; }

                // 查询站点详细信息
                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                if (staDetl == null) {
                    log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    News.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    break;
//                    continue;
                }
                //查询在库信息
                LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                        .eq("loc_sts", "R")
                        .eq("loc_no", wrkMast.getSourceLocNo()));
                if (Cools.isEmpty(locMast)) {
                    News.error("出库 ===>> 库位中没有这笔资料", wrkMast.getSourceLocNo());
                    continue;
                }

                // 判断堆垛机出库站状态
                if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() !=null && staDetl.getCanouting().equals("Y")
                if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
                        && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
                    // 命令下发区 --------------------------------------------------------------------------

@@ -840,13 +816,13 @@
                        if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            if (null == waitWrkMast) {
                                log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                                News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                            } else {
                                if(waitWrkMast.getWrkSts() == 11) {
                                if (waitWrkMast.getWrkSts() == 11) {
                                    waitWrkMast.setIoPri(15D);
                                    waitWrkMast.setModiTime(new Date());
                                    if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                        log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                        News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                    }
                                    continue;
                                } else {
@@ -857,17 +833,17 @@
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            // 此标记避免多次执行移库任务
                            if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())
                                || Cools.isEmpty(waitWrkMast)) {
                                    || Cools.isEmpty(waitWrkMast)) {
                                wrkMast.setUpdMk("Y");
                                wrkMastMapper.updateById(wrkMast);
                                // 生成工作档,将浅库位移转到新的库位中
                                moveLocForDeepLoc(slave, shallowLoc);
                            }
                            log.error("{}任务出库失败，浅库位堵塞！", wrkMast.getWrkNo());
                            News.error("{}任务出库失败，浅库位堵塞！", wrkMast.getWrkNo());
                            continue;
                        } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")){
                        } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")) {
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            if (null != waitWrkMast && waitWrkMast.getWrkSts()==4) {
                            if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
                                continue;
                            }
                        }
@@ -891,8 +867,9 @@
                    crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                    crnCommand.setBarcode(wrkMast.getBarcode());
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                        log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                        News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                        Date now = new Date();
@@ -900,11 +877,12 @@
                        wrkMast.setCrnStrTime(now);
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                            News.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        break;
                    }
                }

            }
        }
    }
@@ -1029,16 +1007,35 @@
    /**
     * 库位移转
     */
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol) {
//        log.info("开始移库任务程序");
        //获取所有移库任务
        List<WrkMast> wrkMasts = wrkMastMapper.selectLocMoves(slave.getId());
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
        if (null == wrkMast) {
        WrkMast wrkMast = null;
        if (Cools.isEmpty(wrkMasts)) {
            return;
        } else {
            wrkMast = wrkMasts.get(0);
        }
//        //后查等待库位转测试库位
//        if (Cools.isEmpty(wrkMast)) {
//            for (WrkMast wm : wrkMasts) {
//                LocMast sourceSta1 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", wm.getSourceLocNo()));
//                if (sourceSta1.getLocType1() == 3) {
//                    wrkMast = wm;
//                }
//            }
//        }
//        //都没有满足条件的，跳过移库
//        if (Cools.isEmpty(wrkMast)) {
//            return;
//        }

        // 获取源库位信息
        LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
        if (null == sourceSta) {
            log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            News.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            return;
        }
        // 源库位  库位状态判断
@@ -1048,7 +1045,7 @@
        // 获取目标库位信息
        LocMast sta = locMastService.selectById(wrkMast.getLocNo());
        if (null == sta) {
            log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            News.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            return;
        }
        // 获取堆垛机信息 并 判断是否可入出
@@ -1067,6 +1064,12 @@
            return;
        }

        //测试库位出库必须要按启动按钮才能出库
        if (sourceSta.getLocType1() == 1 && sourceSta.getCtnKind() == 0) {
            News.error("出库 ===>> 等待启动按钮", wrkMast);
            return;
        }

        // 命令下发区 --------------------------------------------------------------------------
        CrnCommand crnCommand = new CrnCommand();
        crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
@@ -1079,8 +1082,9 @@
        crnCommand.setDestinationPosX(sta.getRow1().shortValue());     // 目标库位排
        crnCommand.setDestinationPosY(sta.getBay1().shortValue());     // 目标库位列
        crnCommand.setDestinationPosZ(sta.getLev1().shortValue());     // 目标库位层
        crnCommand.setBarcode(wrkMast.getBarcode());//托盘码
        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
            log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
            News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
        } else {
            // 修改工作档状态 11.生成出库ID => 12.吊车出库中
            Date now = new Date();
@@ -1088,10 +1092,10 @@
            wrkMast.setCrnStrTime(now);
            wrkMast.setModiTime(now);
            if (wrkMastMapper.updateById(wrkMast) == 0) {
                log.error("【库位移转】 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                News.error("【库位移转】 修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
            }
        }

        log.info("结束移库任务程序");
    }

    /**
@@ -1103,17 +1107,19 @@
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }
            if (crnProtocol == null) {
                continue;
            }
            //  状态：等待确认 并且  任务完成位 = 1
            if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
                if(crnProtocol.getTaskNo()==9999){
                if (crnProtocol.getTaskNo() == 9999) {
                    // 堆垛机复位
                    crnThread.setResetFlag(true);
                }else {
                } else {
                    // 获取入库待确认工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue());
                    if (wrkMast == null) {
                        log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        continue;
                    }
                    // 入库 + 库位转移  ==> 4.入库完成
@@ -1140,7 +1146,7 @@
     * 堆垛机异常信息记录
     */
    @Async
    public void recCrnErr(){
    public void recCrnErr() {
        Date now = new Date();
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
@@ -1162,7 +1168,7 @@
                                continue;
                            }
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
                            String errName = crnError==null? String.valueOf(crnProtocol.getAlarm()):crnError.getErrName();
                            String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName();
                            BasErrLog basErrLog = new BasErrLog(
                                    null,    // 编号
                                    wrkMast.getWrkNo(),    // 工作号
@@ -1201,7 +1207,7 @@
                            }
                        }
                    }
                // 无任务
                    // 无任务
                } else {
                    BasErrLog latest = basErrLogService.findLatest(crn.getId());
                    // 有异常
@@ -1209,7 +1215,7 @@
                        // 记录新异常
                        if (latest == null || (latest.getErrCode() != crnProtocol.getAlarm().intValue())) {
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
                            String errName = crnError==null? String.valueOf(crnProtocol.getAlarm()):crnError.getErrName();
                            String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName();
                            BasErrLog basErrLog = new BasErrLog(
                                    null,    // 编号
                                    null,    // 工作号
@@ -1224,7 +1230,7 @@
                                    null,    // 源站
                                    null,    // 源库位
                                    null,    // 条码
                                    (int)crnProtocol.getAlarm(),    // 异常码
                                    (int) crnProtocol.getAlarm(),    // 异常码
                                    errName,    // 异常
                                    1,    // 异常情况
                                    now,    // 添加时间
@@ -1237,7 +1243,7 @@
                                log.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
                            }
                        }
                    // 无异常
                        // 无异常
                    } else {
                        // 异常修复
                        if (latest != null && latest.getStatus() == 1) {
@@ -1262,7 +1268,7 @@
     * 空栈板初始化入库,叉车入库站放货
     */
    @Async
    public void storeEmptyPlt(){
    public void storeEmptyPlt() {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历空板入库口
            for (DevpSlave.Sta emptyInSta : devp.getEmptyInSta()) {
@@ -1308,14 +1314,12 @@
                                throw new CoolException("更新plc站点信息失败");
                            }
                        } else {
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }




//                    // 检索库位
@@ -1382,7 +1386,8 @@
     * 出库  ===>> 工作档信息写入led显示器
     */
    @Async
    public void ledExecute() {
    public synchronized void ledExecute(Integer mark) {

        for (LedSlave led : slaveProperties.getLed()) {
            // 获取输送线plc线程
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
@@ -1400,13 +1405,24 @@
                }
                // 获取工作档数据
                WrkMast wrkMast = wrkMastMapper.selectById(staProtocol.getWorkNo());
                if (null == wrkMast || wrkMast.getWrkSts() < 14 || wrkMast.getIoType() < 100) { continue; }
//                if (null == wrkMast || wrkMast.getWrkSts() < 14 || wrkMast.getIoType() < 100) { continue; }
                if (null == wrkMast) {
                    continue;
                }
                log.info("" + mark + " - 0" + " - 开始执行:出库  ===>> 工作档信息写入led显示器");
                wrkMasts.add(wrkMast);
                // 组装命令
                LedCommand ledCommand = new LedCommand();
                ledCommand.setWorkNo(wrkMast.getWrkNo());
                ledCommand.setIoType(wrkMast.getIoType());
                // 出库模式
                switch (wrkMast.getIoType()) {
                    case 1:
                        ledCommand.setTitle("全板入库");
                        break;
                    case 10:
                        ledCommand.setTitle("空板入库");
                        break;
                    case 101:
                        ledCommand.setTitle("全板出库");
                        break;
@@ -1424,14 +1440,16 @@
                        ledCommand.setEmptyMk(true);
                        break;
                    default:
                        log.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
                        News.error("" + mark + " - 1" + " - 任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
                        break;
                }
                ledCommand.setSourceLocNo(wrkMast.getSourceLocNo());
                ledCommand.setLocNo(wrkMast.getLocNo());
                ledCommand.setStaNo(wrkMast.getStaNo());
                if (wrkMast.getIoType() != 110) {
//                ledCommand.setSourceStaNo(wrkMast.getSourceStaNo());
                if (wrkMast.getIoType() != 110 && wrkMast.getIoType() != 10) {
                    List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme())));
                    wrkDetls.forEach(wrkDetl -> ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getAnfme(), wrkDetl.getSpecs())));
                }
                commands.add(ledCommand);
            }
@@ -1442,10 +1460,29 @@
            if (CollectionUtils.equals(ledThread.getWorkNos(), workNos)) {
                continue;
            }
//             命令下发 -------------------------------------------------------------------------------
//            if (!commands.isEmpty()) {
//                if (led.getId() < 7) {
//                    if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(3, commands))) {
//                        News.error(""+mark+" - 2"+" - {}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
//                        continue;
//                    } else {
//                        ledThread.setLedMk(false);
//                    }
//                } else {
//                    if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
//                        News.error(""+mark+" - 3"+" - {}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
//                        continue;
//                    } else {
//                        ledThread.setLedMk(false);
//                    }
//                }
//
//            }
            // 命令下发 -------------------------------------------------------------------------------
            if (!commands.isEmpty()) {
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
                    log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(3, commands))) {
                    News.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                    continue;
                } else {
                    ledThread.setLedMk(false);
@@ -1458,6 +1495,7 @@
                    wrkMast.setOveMk("Y");
                    wrkMast.setModiTime(new Date());
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        log.error("" + mark + " - 4" + " - 更新工作档失败");
                        throw new CoolException("更新工作档失败");
                    }
                }
@@ -1471,6 +1509,7 @@
            }

        }
        log.info("" + mark + " - 0" + " - 出库  ===>> 工作档信息写入led显示器执行完成");
    }

    /**
@@ -1524,12 +1563,12 @@
            // 获取led线程
            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
            // led显示默认内容
            if (reset && !ledThread.isLedMk()) {
                ledThread.setLedMk(true);
            if (reset) {
                if (ledThread == null) {
                    continue;
                }
                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) {
                    log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                } else {

                    News.error("{}号LED显示默认命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                }
            }
        }
@@ -1540,7 +1579,7 @@
     * tip：同步
     */
    @Transactional
    public synchronized void moveLocForDeepLocPakin(CrnSlave crn, LocMast shallowLoc, WrkMast pakinWrkMast){
    public synchronized void moveLocForDeepLocPakin(CrnSlave crn, LocMast shallowLoc, WrkMast pakinWrkMast) {
        LocMast loc = locMastService.selectById(pakinWrkMast.getLocNo());

        // 获取工作号
@@ -1559,7 +1598,7 @@
        wrkMast.setFullPlt(shallowLoc.getFullPlt()); // 满板
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D")?"Y":"N"); // 空板
        wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板
        wrkMast.setBarcode(shallowLoc.getBarcode()); // 托盘码
        wrkMast.setLinkMis("N");
        wrkMast.setCtnNo("Y");  // 入库阻塞库位移转标记
@@ -1589,7 +1628,7 @@
        if (shallowLoc.getLocSts().equals("D") || shallowLoc.getLocSts().equals("F")) {
            shallowLoc.setLocSts("S"); // S.入库预约，入库阻塞库位移转
            shallowLoc.setModiTime(now);
            if (!locMastService.updateById(shallowLoc)){
            if (!locMastService.updateById(shallowLoc)) {
                throw new CoolException("更新源库位状态失败");
            }
        } else {
@@ -1615,7 +1654,7 @@
     * 因双深库位阻塞，对浅库位进行移转（立即执行版)
     * tip：同步
     */
    private void moveLocForDeepLoc(CrnSlave crn, LocMast shallowLoc){
    private void moveLocForDeepLoc(CrnSlave crn, LocMast shallowLoc) {
        try {
            List<Integer> rows = locMastService.queryDistinctRow(crn.getId());
            LocMast loc = null;
@@ -1732,7 +1771,7 @@
    /**
     * 堆垛机演示  ===>> 库位移转
     */
    public synchronized void crnDemoOfLocMove1(){
    public synchronized void crnDemoOfLocMove1() {
        try {
            for (CrnSlave crn : slaveProperties.getCrn()) {
                if (!crn.getDemo()) {
@@ -1833,7 +1872,7 @@
    /**
     * 堆垛机命令下发后，异步修改工作档状态
     */
    public synchronized void crnIoWrkMast(){
    public synchronized void crnIoWrkMast() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
@@ -1846,18 +1885,20 @@
            if (crnProtocol.getStatusType() != CrnStatusType.IDLE && crnProtocol.getTaskNo() != 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                // 获取工作档
                WrkMast wrkMast = wrkMastMapper.selectById(crnProtocol.getTaskNo());
                if (wrkMast == null) { continue; }
                if (wrkMast == null) {
                    continue;
                }
                // 入库
                if (wrkMast.getWrkSts() == 1 || wrkMast.getWrkSts() == 2) {
                    log.warn("堆垛机非空闲情况下，开始修改工作档状态。[id:{},时间：{}] >>>>> 堆垛机当前状态为：{}。任务号:{}", crn.getId(), DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F), crnProtocol.getStatusType().desc, crnProtocol.getTaskNo());
                    News.warn("堆垛机非空闲情况下，开始修改工作档状态。[id:{},时间：{}] >>>>> 堆垛机当前状态为：{}。任务号:{}", crn.getId(), DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F), crnProtocol.getStatusType().desc, crnProtocol.getTaskNo());
                    // 修改工作档状态 2.设备上走 => 3.吊车入库中
                    wrkMast.setWrkSts(3L);
                    wrkMast.setCrnStrTime(now);
                    wrkMast.setModiTime(now);
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        News.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                    }
                    log.warn("修改工作档状态成功。[时间：{}] >>>>> 任务号:{}",  DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F),  wrkMast.getWrkNo());
                    News.warn("修改工作档状态成功。[时间：{}] >>>>> 任务号:{}", DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F), wrkMast.getWrkNo());
                }
                // 出库、移库
                if (wrkMast.getWrkSts() == 11) {
@@ -1867,46 +1908,14 @@
                    wrkMast.setCrnStrTime(now);
                    wrkMast.setModiTime(now);
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        News.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                    }
                    log.warn("修改工作档状态成功。[时间：{}] >>>>> 任务号:{}",  DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F),  wrkMast.getWrkNo());
                    News.warn("修改工作档状态成功。[时间：{}] >>>>> 任务号:{}", DateUtils.convert(now, DateUtils.yyyyMMddHHmmsssss_F), wrkMast.getWrkNo());
                }


            }

        }
    }

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

                WrkMast pakout = wrkMastMapper.selectWorkingPakout();
                if (pakout != null) {
                    if (devpThread.ioMode != IoModeType.PAKOUT_MODE) {
                        // 出库切换中
                        devpThread.ioMode = IoModeType.PAKOUT_BOOTING;

                        WrkMast pakin = wrkMastMapper.selectWorkingPakin();
                        if (pakin == null) {
                            // 出库模式
                            devpThread.ioMode = IoModeType.PAKOUT_MODE;
                        }
                    }
                } else {
                    // 入库模式
                    devpThread.ioMode = IoModeType.PAKIN_MODE;
                }
            }

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

@@ -1927,9 +1936,11 @@
     * 站到站  ===>>  堆垛机109站到108站
     * 109防爆沙箱站点 出库 到 108站点
     */
    public void stnToStn(CrnSlave slave, CrnProtocol crnProtocol){
    public void stnToStn(CrnSlave slave, CrnProtocol crnProtocol) {
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            if(crnStn.getStaNo()!=109){ continue; }
            if (crnStn.getStaNo() != 109) {
                continue;
            }

            boolean flag = false;
            // 获取堆垛机入库站信息
@@ -1943,11 +1954,11 @@
            // 查询站点详细信息
            BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
            if (staDetl == null) {
                log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                News.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                continue;
            }
            if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
                    && staDetl.getCanining()!=null && staDetl.getCanining().equals("Y")) {
                    && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
                flag = true;
            }

@@ -1978,241 +1989,185 @@
            // 命令下发区 --------------------------------------------------------------------------
            CrnCommand crnCommand = new CrnCommand();
            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
            crnCommand.setTaskNo((short)9999); // 工作号
            crnCommand.setTaskNo((short) 9999); // 工作号
            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((short)2);     // 目标库位排
            crnCommand.setDestinationPosY((short)19);     // 目标库位列
            crnCommand.setDestinationPosZ((short)1);     // 目标库位层
            crnCommand.setDestinationPosX((short) 2);     // 目标库位排
            crnCommand.setDestinationPosY((short) 19);     // 目标库位列
            crnCommand.setDestinationPosZ((short) 1);     // 目标库位层
            if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(2, crnCommand))) {
                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", 1, JSON.toJSON(crnCommand));
                News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", 1, JSON.toJSON(crnCommand));
            } else {
            }
        }
    }


    public boolean messageQueueOffer(int i, short newSingle, SlaveType devp, Integer id) {
        //复位PLC信号，借用输送站点实体类
        StaProtocol staProtocol = new StaProtocol();
        staProtocol.setSiteId(i * 2);//寄存器地址
        staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,8==>0
        return MessageQueue.offer(devp, id, new Task(3, staProtocol));
    }

    public boolean messageQueueOffer2(int i, short newSingle, SlaveType devp, Integer id) {
        //复位PLC信号，借用输送站点实体类
        StaProtocol staProtocol = new StaProtocol();
        staProtocol.setSiteId(i);//寄存器地址
        staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,8==>0
        return MessageQueue.offer(devp, id, new Task(5, staProtocol));
    }

    /**
     * 根据PLC按钮测试、完成、暂停信号，更新testMast表中status值，交由WMS系统处理
     * 更新PLC库位状态、更新库位启动状态
     */
    @Transactional
    public void packTest() {
    public void packTest1() {
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                if(null != devpThread){
                    for (int i = 0; i < 48; i++){
                        int olsStatus = 0;//testMast表原来status数据状态
                        int newStatus = 0;//testMast表待修改的status数据状态
                        short newSingle = 0;  //PLC地址待修改的新值
                        switch (devpThread.startSignal[i]){//根据信号查找testMast表中对应状态条件,olsStatus，newStatus根据实际流程调整
                            case 1://启动复核信号
                                olsStatus = 2;
                                newStatus = 3;
                                newSingle = 2;//测试复核，寄存器地址，1===>>2
                                break;
                            case 2://完成测试信号
                                olsStatus = 3;
                                newStatus = 3;
                                newSingle = 3;//测试完成，寄存器地址清零，2===>>3
                            case 4://完成测试信号
                                olsStatus = 3;
                                newStatus = 4;
                                newSingle = 0;//测试完成，寄存器地址清零，4===>>0
                                break;
                            case 5://暂停信号
                                olsStatus = 99;//plc给出暂停信号
                                newStatus = 0;//WCS收到暂停信号后，更新testMast
                                newSingle = 6;//暂停测试，寄存器地址，5===>>6
                                break;
                            case 7://紧急出库确认充电线已经拔出
                                olsStatus = 99;//plc给出暂停信号
                                newStatus = 0;//WCS收到暂停信号后，更新testMast
                                newSingle = 6;//暂停测试，寄存器地址，7===>>6
                                break;
                            case 8://解除暂停
                                olsStatus = 99;
                                newStatus = 0;
                                newSingle = 0;//测试复核，寄存器地址，8===>>0
                                break;
                            case 11://入库前判断充电线是否放好
                                olsStatus = 99;
                                newStatus = 0;
                                newSingle = 11;//
                                break;
                            case 12://充电线放好
                                olsStatus = 99;
                                newStatus = 0;
                                newSingle = 0;//测试复核，寄存器地址，12===>>0
                                break;
                        }
                if (null != devpThread) {
                    //devpThread.startSignal[i][0]
                    //0:空闲,1:待测,2:测试中;3.测试完成;4.测试失败;

                        TestMast testMast = testMastService.selectOne(new EntityWrapper<TestMast>()
                                .eq("channel",(i+1)).eq("status",olsStatus));//查找原来的状态
                        if(null != testMast &&
                                (devpThread.startSignal[i] == 1 || devpThread.startSignal[i] == 3)){
                            testMast.setStatus(newStatus);
                            testMast.setModiTime(new Date());
                            if(!testMastService.update(testMast,new EntityWrapper<TestMast>()
                                    .eq("channel",(i+1)).eq("status",olsStatus))){
                                throw new CoolException("更新产品测试状态失败");
                            }
                            //复位PLC信号，借用输送站点实体类
                            StaProtocol staProtocol = new StaProtocol();
                            staProtocol.setSiteId(i*2);//寄存器地址
                            staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,1==>2或3==>0,5==>6
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
                            if(!result){
                                log.error("更新测试信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, testMast.getLocNo(), testMast.getBarcode());
//                                throw new CoolException("更新测试信号失败===>>" + i);
                            } else {
                                devpThread.startSignal[i] = newSingle;
                            }
                        }else if (null != testMast && devpThread.startSignal[i] == 2){
                            if (testMast.getStatus()==3){
                                LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                                        .eq("channel",(i+1)));
                                if (locMast.getLocSts().equals("F") && locMast.getPackStatus()==3){
                                    //复位PLC信号，借用输送站点实体类
                                    StaProtocol staProtocol = new StaProtocol();
                                    staProtocol.setSiteId(i*2);//寄存器地址
                                    staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,2==>3
                                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
                                    if(!result){
                                        log.error("更新测试信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, testMast.getLocNo(), testMast.getBarcode());
//                                throw new CoolException("更新测试信号失败===>>" + i);
                                    } else {
                                        devpThread.startSignal[i] = newSingle;
                    //locMast.setPackStatus
                    // "产品状态{0:空闲,1:待测,2:测试中;3.测试完成;4.测试失败;}"

                    //testMast.setStatus
                    //"状态 0: 无货  1: 等待测试 2:测试中 3.测试完成;4.测试失败; "
                    for (int i = 0; i < 24; i++) {
                        //查询在库和预约出库
                        LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel", i + 1));
                        if (!Cools.isEmpty(locMast)) {
                            if (locMast.getLocSts().equals("F")) {
                                TestMast testMast = testMastService.selectOne(new EntityWrapper<TestMast>()
                                        .eq("loc_no", locMast.getLocNo())
                                        .eq("user_id", locMast.getBarcode()));
                                if (Cools.isEmpty(testMast)) {
//                                log.info("2377行程序开始运行，测试档为空，跳过");
                                    continue;
                                }
                                HashMap<String, Short> hashMap = new HashMap<>();
                                if (devpThread.startSignal[i][0] != locMast.getPackStatus()) {
                                    hashMap.put("locSts", locMast.getPackStatus().shortValue());
                                    hashMap.put("channel", (short) (i * 2));
                                    MessageQueue.offer(SlaveType.Devp, 1, new Task(6, hashMap));
                                }
                                //同步设备状态
                                if (locMast.getPackStatus() != testMast.getStatus()) {
                                    testMast.setStatus(locMast.getPackStatus());
                                    testMastService.updateById(testMast);
                                }
                                if (devpThread.startSignal[i][1] != locMast.getCtnKind()) {
                                    locMast.setCtnKind(devpThread.startSignal[i][1]);
                                    locMastService.updateById(locMast);
                                }
                            } else if (locMast.getLocSts().equals("O")) {
                                //当充放电库位为O空库位时
                                //库位状态改为0空闲
                                locMast = locMastService.selectztgx("O", i);
                                if (!Cools.isEmpty(locMast)) {
                                    HashMap<String, Short> hashMap = new HashMap<>();
                                    if (devpThread.startSignal[i][0] != locMast.getPackStatus()) {
                                        hashMap.put("locSts", (short) 0);
                                        hashMap.put("channel", (short) (i * 2));
                                        MessageQueue.offer(SlaveType.Devp, 1, new Task(6, hashMap));
                                        locMast.setPackStatus(0);
                                        locMastService.updateById(locMast);
                                    }

                                    if (devpThread.startSignal[i][1] != locMast.getChannel()) {
                                        locMast.setCtnKind(devpThread.startSignal[i][1]);
                                        locMastService.updateById(locMast);
                                    }
                                }
                            }
                        }else if (devpThread.startSignal[i] == 5){
                            SearchLocParam param = new SearchLocParam();
                            param.setBarcode(i+1+"");
                            String response = new HttpHandler.Builder()
                                    .setUri(wmsUrl)
                                    .setPath("/mobile/test/suspend/auth")
                                    .setJson(JSON.toJSONString(param))
                                    .build()
                                    .doPost();
                            JSONObject jsonObject = JSON.parseObject(response);
                            if (jsonObject.getInteger("code").equals(200)) {
                                //复位PLC信号，借用输送站点实体类
                                StaProtocol staProtocol = new StaProtocol();
                                staProtocol.setSiteId(i*2);//寄存器地址
                                staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,5==>6
                                boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
                                if(!result){
                                    log.error("暂停测试失败===>>["+i+1+"]号通道");
//                                throw new CoolException("更新测试信号失败===>>" + i);
                                } else {
                                    devpThread.startSignal[i] = newSingle;
                                }
                            } else {
                                log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/mobile/test/suspend/auth", JSON.toJSONString(param), response);
                            }
                        }else if (devpThread.startSignal[i] == 7){
                            LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                                    .eq("channel",(i+1)));
                            if (locMast.getLocSts().equals("F")){
                                locMast.setPackStatus(8); //8.紧急出库
                                locMastService.update(locMast,new EntityWrapper<LocMast>()
                                        .eq("channel",(i+1)));
                            }
                            //复位PLC信号，借用输送站点实体类
                            StaProtocol staProtocol = new StaProtocol();
                            staProtocol.setSiteId(i*2);//寄存器地址
                            staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,7==>6
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
                            if(!result){
                                log.error("更新库位紧急出库信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, locMast.getLocNo(), locMast.getBarcode());
//                                throw new CoolException("更新测试信号失败===>>" + i);
                            } else {
                                devpThread.startSignal[i] = newSingle;
                            }
                        }else if (devpThread.startSignal[i] == 8){
                            //复位PLC信号，借用输送站点实体类
                            StaProtocol staProtocol = new StaProtocol();
                            staProtocol.setSiteId(i*2);//寄存器地址
                            staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,8==>0
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
                            if(!result){
//                                log.error("更新库位紧急出库信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, locMast.getLocNo(), locMast.getBarcode());
//                                throw new CoolException("更新测试信号失败===>>" + i);
                            } else {
                                devpThread.startSignal[i] = newSingle;
                            }
                        }else if (devpThread.startSignal[i] == 11){
                            LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                                    .eq("channel",(i+1)));
                            if (locMast.getLocSts().equals("O")){
                                locMast.setLocSts("X");
                                locMastService.update(locMast,new EntityWrapper<LocMast>()
                                        .eq("channel",(i+1)));
                            }
                        }else if (devpThread.startSignal[i] == 12){
                            LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                                    .eq("channel",(i+1)));
                            if (locMast.getLocSts().equals("X")){
                                locMast.setLocSts("O");
                                locMastService.update(locMast,new EntityWrapper<LocMast>()
                                        .eq("channel",(i+1)));
                            }
                            //复位PLC信号，借用输送站点实体类
                            StaProtocol staProtocol = new StaProtocol();
                            staProtocol.setSiteId(i*2);//寄存器地址
                            staProtocol.setStaNo(newSingle);//修改PLC寄存器地址值,12==>0
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
                            if(!result){
//                                log.error("更新库位紧急出库信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, locMast.getLocNo(), locMast.getBarcode());
//                                throw new CoolException("更新测试信号失败===>>" + i);
                            } else {
                                devpThread.startSignal[i] = newSingle;
                            }
                        }else { }
                        }
                    }

                }

            }
        } catch (Exception e) {
            log.error("启动测试  ===>> 启动测试失败", e);
            News.error("获得测试库位状态失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

    /**
     * 将火警报警信号写入到堆垛机PLC中
     * 出库站点无货时自动补空板到出库口
     */
    @Transactional
    public void fierCrn() {
        try {
            for (CrnSlave crn :slaveProperties.getCrn()) {
                // 获取堆垛机信息
                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
                CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("fire_status", 1));
                if (!Cools.isEmpty(locMast)){
                    //报警信号写入1
                    if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(4, (short)1))) {
                        log.error("火警  ===>> 给堆垛机发送报警信号失败");
                    }
                } else {
                    //报警信号没有后，复位地址
                    if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(4, (short)0))) {
                        log.error("火警  ===>> 给堆垛机清零复位报警信号失败");
                    }
    public void automaticEmptyBoardOutbound() {
        // 获取入库站信息
        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        StaProtocol staProtocol = devpThread.getStation().get(101);
        if (staProtocol == null) {
            return;
        } else {
            staProtocol = staProtocol.clone();
        }
        if (staProtocol.isAutoing() && !staProtocol.isLoading()
                && staProtocol.isOutEnable() && staProtocol.getWorkNo() == 0
        ) {
            WrkMast wrkMast1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("io_type", 110));
            if (!Cools.isEmpty(wrkMast1)) {
                return;
            }
            LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_sts", "D").orderBy("row1"));
            if (Cools.isEmpty(locMast)) {
                return;
            }
            //生成空板出库任务
            // 获取工作号
            int workNo = commonService.getWorkNo(WorkNoType.PAKOUT.type);
            // 获取源站
            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                    .eq("type_no", 110)
                    .eq("stn_no", 101)
                    .eq("crn_no", locMast.getCrnNo());
            StaDesc staDesc = staDescService.selectOne(wrapper);
            Integer sourceStaNo = staDesc.getCrnStn();
            if (Cools.isEmpty(sourceStaNo)) {
                throw new CoolException("检索源站失败");
            }
            Date now = new Date();
            // 保存工作档
            WrkMast wrkMast = new WrkMast();
            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(now);
            wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
            wrkMast.setIoType(110); // 入出库状态： 110.空板出库
            wrkMast.setIoPri(10D);
            wrkMast.setSourceStaNo(sourceStaNo); // 源站
            wrkMast.setStaNo(staDesc.getStnNo()); // 目标站
            wrkMast.setCrnNo(locMast.getCrnNo());
            wrkMast.setSourceLocNo(locMast.getLocNo()); // 源库位
            wrkMast.setFullPlt("N"); // 满板：Y
            wrkMast.setPicking("N"); // 拣料
            wrkMast.setExitMk("N"); // 退出
            wrkMast.setEmptyMk("Y"); // 空板
            wrkMast.setLinkMis("N");
            wrkMast.setAppeUser(9995L);
            wrkMast.setAppeTime(now);
            wrkMast.setModiUser(9995L);
            wrkMast.setModiTime(now);
            boolean res = wrkMastService.insert(wrkMast);
            if (!res) {
                throw new CoolException("保存工作档失败");
            }
            // 更新库位状态 D.空板 -> R.出库预约
            if (locMast.getLocSts().equals("D")){
                locMast.setLocSts("R");
                locMast.setModiUser(9995L);
                locMast.setModiTime(now);
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException("更新库位状态失败");
                }
            }
        } catch (Exception e) {
            log.error("火警  ===>> 给堆垛机发送警报失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

}