初始化程序

野心家

2024-12-05 231e55d38511146988fac0d1b09432d8742d5656

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

@@ -25,6 +25,7 @@
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.*;
import com.zy.core.enums.DevpType.DevpWorkType;
import com.zy.core.model.CrnSlave;
import com.zy.core.model.DevpSlave;
import com.zy.core.model.LedSlave;
@@ -46,6 +47,7 @@
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;
@@ -111,35 +113,74 @@
            for (DevpSlave.Sta inSta : devp.getInSta()) {
                // 获取条码扫描仪信息
                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();
                }
                //staProtocol.setPakMk(true);
//                // 入出库模式判断
//                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;
                }
                // 退回
                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;
                }
                String barcode = barcodeThread.getBarcode();
                if (!Cools.isEmpty(barcode)&&!barcode.equals("00000000")) {
                    log.info("{}号条码扫描器检测条码信息：{}", inSta.getBarcode(), barcode);
                    if ("NG".endsWith(barcode) || "NoRead".equals(barcode)) {
                        continue;
                    }
                } else {
                    // led 异常显示
//                    LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, inSta.getLed());
//                    if (ledThread != null) {
//                        String errorMsg = "扫码失败，请重试";
//                        MessageQueue.offer(SlaveType.Led, inSta.getLed(), new Task(3, errorMsg));
//                    }
                    continue;
                }

                if (staProtocol.isAutoing() && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk() && (staProtocol.getWorkNo() == 0 || staProtocol.getWorkNo() == 9999)
                        && !staProtocol.isEmptyMk() && (staProtocol.getWorkNo() >= 9992 && staProtocol.getWorkNo() <= 9999)
                        && staProtocol.isPakMk()){// && !Cools.isEmpty(barcode)) {

//                    if(Cools.isEmpty(barcode) || "NG".endsWith(barcode) || "NoRead".equals(barcode)) {
@@ -156,33 +197,19 @@
//                    }

                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode.substring(0,6));
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
                    if (wrkMast != null) {
                        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;
//                    }
                    // 获取入库通知档
                    List<WaitPakin> waitPakins = waitPakinMapper.selectList(new EntityWrapper<WaitPakin>().eq("zpallet", barcode).eq("io_status", "N"));
                    if (waitPakins.isEmpty()) {
                        log.error("无此入库条码数据。条码号={}", barcode);
                        continue;
                    }

                    try {
                        String pack =null;//pack码
                        if(barcode.length()>6){
                            pack=barcode.substring(6);
                            if(pack.equals("00000000000000000000")){
                                News.error("没有获得Pack码",pack);
                                continue;
                            }
                        }
                        //String pack="MJY0136 0400";
                        barcode=barcode.substring(0,6);//托盘码
                        if(barcode.equals("000000")){
                            News.error("没有获得条码",barcode);
                            continue;
                        }
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
                        locTypeDto.setLocType1((short)1);
                        SearchLocParam param = new SearchLocParam();
@@ -190,7 +217,7 @@
                        param.setIoType(1);
                        param.setSourceStaNo(inSta.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        param.setPackNo(pack);
//                        param.setPackNo(pack);
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/loc/v1")
@@ -212,79 +239,20 @@
                        } else if (jsonObject.getInteger("code").equals(700) && (!barcodeThread.getBarcode().equals("NG"))){
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);
                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo((short)9999);
                            staProtocol.setStaNo((short)201);
                            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));
                            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)9999);
                            staProtocol.setStaNo((short)201);
                            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));
                            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();
@@ -857,62 +825,12 @@
                    continue;
                }


                // 判断堆垛机出库站状态
                if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() !=null && staDetl.getCanouting().equals("Y")
                        && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
                    //测试库位出库必须要按启动按钮才能出库
                    if((wrkMast.getStaNo()==206 || wrkMast.getStaNo()==1000)&& locMast.getCtnKind()==0){
                        News.error("出库 ===>> 等待启动出库按钮",wrkMast);
                        continue;
                    }
                    // 命令下发区 --------------------------------------------------------------------------

                //消防报警出库
                if(wrkMast.getStaNo()==1000&& locMast.getCtnKind()==1){
                    // 堆垛机控制过滤
                    if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
//                        continue;
                        break;
                    }

                    // 双深库位且浅库位有货，则需先对浅库位进行库位移转
                    if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
                        String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getSourceLocNo());
                        LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                        // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！
                        if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            if (null == waitWrkMast) {
                                News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                            } else {
                                if(waitWrkMast.getWrkSts() == 11) {
                                    waitWrkMast.setIoPri(15D);
                                    waitWrkMast.setModiTime(new Date());
                                    if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                        News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                    }
                                    continue;
                                } else {

                                }
                            }
                        } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            // 此标记避免多次执行移库任务
                            if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())
                                || Cools.isEmpty(waitWrkMast)) {
                                wrkMast.setUpdMk("Y");
                                wrkMastMapper.updateById(wrkMast);
                                // 生成工作档,将浅库位移转到新的库位中
                                moveLocForDeepLoc(slave, shallowLoc);
                            }
                            News.error("{}任务出库失败，浅库位堵塞！", wrkMast.getWrkNo());
                            continue;
                        } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")){
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            if (null != waitWrkMast && waitWrkMast.getWrkSts()==4) {
                                continue;
                            }
                        }
                    }

                    // 已经存在吊车执行任务时，则过滤
@@ -920,7 +838,6 @@
                        break;
//                        return;
                    }


                    // 1.堆垛机开始移动
                    CrnCommand crnCommand = new CrnCommand();
@@ -947,6 +864,98 @@
                            News.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        break;
                    }
                }else {
                    // 判断堆垛机出库站状态
                    if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() !=null && staDetl.getCanouting().equals("Y")
                            && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
                        //测试库位出库必须要按启动按钮才能出库
                        if((wrkMast.getStaNo()==206 || wrkMast.getStaNo()==1000)&& locMast.getCtnKind()==0){
                            News.error("出库 ===>> 等待启动出库按钮",wrkMast);
                            continue;
                        }
                        // 命令下发区 --------------------------------------------------------------------------

                        // 堆垛机控制过滤
                        if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
//                        continue;
                            break;
                        }

                        // 双深库位且浅库位有货，则需先对浅库位进行库位移转
                        if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
                            String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getSourceLocNo());
                            LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                            // O.空库位、Q.拣料/盘点/并板再入库、S.入库预约、X.禁用 直接搬！
                            if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                                WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                                if (null == waitWrkMast) {
                                    News.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                                } else {
                                    if(waitWrkMast.getWrkSts() == 11) {
                                        waitWrkMast.setIoPri(15D);
                                        waitWrkMast.setModiTime(new Date());
                                        if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                            News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                        }
                                        continue;
                                    } else {

                                    }
                                }
                            } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                                WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                                // 此标记避免多次执行移库任务
                                if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())
                                        || Cools.isEmpty(waitWrkMast)) {
                                    wrkMast.setUpdMk("Y");
                                    wrkMastMapper.updateById(wrkMast);
                                    // 生成工作档,将浅库位移转到新的库位中
                                    moveLocForDeepLoc(slave, shallowLoc);
                                }
                                News.error("{}任务出库失败，浅库位堵塞！", wrkMast.getWrkNo());
                                continue;
                            } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")){
                                WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                                if (null != waitWrkMast && waitWrkMast.getWrkSts()==4) {
                                    continue;
                                }
                            }
                        }

                        // 已经存在吊车执行任务时，则过滤
                        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(sourceSta.getRow1().shortValue());     // 源库位排
                        crnCommand.setSourcePosY(sourceSta.getBay1().shortValue());     // 源库位列
                        crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue());     // 源库位层
                        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))) {
                            News.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) {
                                News.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                            break;
                        }
                    }
                }
            }
@@ -1074,19 +1083,17 @@
     * 库位移转
     */
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
        log.info("开始移库任务程序");
//        log.info("开始移库任务程序");
        //获取所有移库任务
        List<WrkMast> wrkMasts=wrkMastMapper.selectLocMoves(slave.getId());
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
        WrkMast wrkMast =null;
        if(Cools.isEmpty(wrkMasts)){
            return;
        }
        if (null == wrkMast) {
            return;
        }
        //先查测试库位转OK或者NG库位按了按钮的
        for (WrkMast wm: wrkMasts) {
            LocMast sourceSta1 = locMastService.selectById(wm.getSourceLocNo());
            LocMast sourceSta1 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no",wm.getSourceLocNo()));
            if (!Cools.isEmpty(sourceSta1.getCtnKind())){
                if(sourceSta1.getCtnKind()==1){
                    wrkMast=wm;
@@ -1094,6 +1101,20 @@
                }
            }
        }
        //后查等待库位转测试库位
        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) {
@@ -1453,7 +1474,7 @@
     * 出库  ===>> 工作档信息写入led显示器
     */
    @Async
    public void ledExecute() {
    public synchronized void ledExecute() {
        for (LedSlave led : slaveProperties.getLed()) {
            // 获取输送线plc线程
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
@@ -1464,20 +1485,27 @@
            for (Integer staNo : led.getStaArr()) {
                // 获取叉车站点
                StaProtocol staProtocol = devpThread.getStation().get(staNo);
                if (null == staProtocol || null == staProtocol.getWorkNo() || 0 == staProtocol.getWorkNo() || !staProtocol.isLoading()) {
                if (null == staProtocol || null == staProtocol.getWorkNo() || 0 == staProtocol.getWorkNo()) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                // 获取工作档数据
                WrkMast wrkMast = wrkMastMapper.selectById(staProtocol.getWorkNo());
                if (null == wrkMast || wrkMast.getWrkSts() < 14 || wrkMast.getIoType() < 100) { continue; }
                if (null == wrkMast) { continue; }
                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;
@@ -1495,16 +1523,39 @@
                        ledCommand.setEmptyMk(true);
                        break;
                    default:
                        log.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
                        News.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkMast.getWrkNo(), wrkMast.getIoType());
                        break;
                }
                ledCommand.setSourceLocNo(wrkMast.getSourceLocNo());
                ledCommand.setStaNo(wrkMast.getStaNo());
                if (wrkMast.getIoType() != 110) {
                ledCommand.setBarcode(wrkMast.getBarcode());
                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 -> {
                        Double total = 0.0;
                        EntityWrapper<LocDetl> wrapper = new EntityWrapper<>();
                        LocDetl locDetl = locDetlService.selectOne(wrapper.eq("zpallet", wrkDetl.getZpallet()).eq("matnr", wrkDetl.getMatnr()));
                        if (Cools.isEmpty(locDetl)) {
                            total = wrkDetl.getAnfme();
                        } else {
                            total = locDetl.getAnfme();
                        }
                        if (wrkMast.getIoType() == 101 || wrkMast.getIoType() == 1) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
                        }
                        if (wrkMast.getIoType() == 103 && (null == wrkDetl.getInspect() || 0 == wrkDetl.getInspect())) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
                        }
                        if (wrkMast.getIoType() == 107 || wrkMast.getIoType() == 104) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getManu(), wrkDetl.getMemo(), wrkDetl.getAnfme(),total));
                        }
                    });
                }
                commands.add(ledCommand);
            }
            if(Cools.isEmpty(wrkMasts)){
                continue;
            }
            Set<Integer> workNos = wrkMasts.stream().map(WrkMast::getWrkNo).collect(Collectors.toSet());
            // 获取LED线程
@@ -1516,10 +1567,8 @@
            // 命令下发 -------------------------------------------------------------------------------
            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());
                    News.error("{}号LED显示内容命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
                    continue;
                } else {
                    ledThread.setLedMk(false);
                }
            }

@@ -1595,12 +1644,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());
                }
            }
        }
@@ -2403,41 +2452,41 @@
                            //testMast.setStatus
                            //"状态 0: 待申请  1: 申请中  2: 已复核 3:测试中 4:完成 5:移库 6:火警"
                            if(devpThread.startSignal[i][0]==8){
                                News.info("2390行程序开始运行，修改测试档状态为 1、申请中，开始修改前："+testMast);
                                News.info("2390行程序开始运行，修改测试档状态为 1、申请中，开始修改前："+ JSON.toJSONString(testMast));
                                testMast.setStatus(1);
                                locMast.setPackStatus(1);
                                testMast.setModiTime(new Date());
                                log.info("2394行程序开始运行，修改测试档状态为 1、申请中,修改数据后、未更新"+testMast);
                                log.info("2394行程序开始运行，修改测试档状态为 1、申请中,修改数据后、未更新"+JSON.toJSONString(testMast));
                            }else if(devpThread.startSignal[i][0]==2 && locMast.getPackStatus()!=2){
                                News.info("2396行程序开始运行，修改测试档状态为 3、测试中，开始修改前："+testMast);
                                News.info("2396行程序开始运行，修改测试档状态为 3、测试中，开始修改前："+JSON.toJSONString(testMast));
                                testMast.setStatus(3);
                                locMast.setPackStatus(2);
                                testMast.setModiTime(new Date());
                                log.info("2400，修改测试档状态为 3、测试中,修改数据后、未更新"+testMast);
                                log.info("2400，修改测试档状态为 3、测试中,修改数据后、未更新"+JSON.toJSONString(testMast));
                                //NG转OK需要还原源库位和目标库位状态，OK转NG 删除任务档
                                WrkMast wrkMast=wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                                        .eq("source_loc_no",locMast.getLocNo())
                                        .eq("wrk_sts",11));
                                News.info("2405，查询状态为生成出库id的测试完成（NG或OK）任务档，"+wrkMast);
                                News.info("2405，查询状态为生成出库id的测试完成（NG或OK）任务档，"+JSON.toJSONString(wrkMast));
                                if(!Cools.isEmpty(wrkMast)){
                                    if(wrkMast.getWrkSts()==11){
                                        if(wrkMast.getIoType()==11){
                                            log.info("2409，删除任务档为移库的，"+wrkMast);
                                            log.info("2409，删除任务档为移库的，"+JSON.toJSONString(wrkMast));
                                            LocMast locMast1=locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no",wrkMast.getLocNo()));
                                            locMast1.setLocSts("O");
                                            locMastService.update(locMast1,new EntityWrapper<LocMast>().eq("loc_no",wrkMast.getLocNo()));
                                        }
                                        wrkMastMapper.deleteById(wrkMast);
                                        log.info("2415，删除工作档"+wrkMast);
                                        log.info("2415，删除工作档"+JSON.toJSONString(wrkMast)+JSON.toJSONString(locMast));
                                        locMast.setLocSts("F");
                                        log.info("2417，删除工作档"+wrkMast);
                                        log.info("2417，删除工作档"+JSON.toJSONString(wrkMast)+JSON.toJSONString(locMast));
                                        wrkDetlService.delete(new EntityWrapper<WrkDetl>().eq("wrk_no",wrkMast.getWrkNo()));
                                        log.info("2419，删除工作明细"+wrkMast.getWrkNo());
                                        if(!locMastService.update(locMast,new EntityWrapper<LocMast>()
                                                .eq("channel",i+1))){
                                            log.error("2422修改测试库位状态失败"+locMast.getLocNo(),locMast);
                                            log.error("2422修改测试库位状态失败"+locMast.getLocNo()+JSON.toJSONString(locMast));
                                        }else{
                                            log.error("2424"+locMast.getLocNo(),locMast);
                                            log.error("2424修改测试库位状态成功"+locMast.getLocNo()+JSON.toJSONString(locMast));
                                            fig=true;
                                        }
                                    }