初始化程序

野心家

2024-12-05 231e55d38511146988fac0d1b09432d8742d5656

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

@@ -19,11 +19,13 @@
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;
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;
@@ -45,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;
@@ -110,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)) {
@@ -155,33 +197,19 @@
//                    }

                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode.substring(0,6));
                    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;
//                    }
                    // 获取入库通知档
                    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")){
                                log.error("没有获得Pack码",pack);
                                continue;
                            }
                    }
                        //String pack="MJY0136 0400";
                        barcode=barcode.substring(0,6);//托盘码
                        if(barcode.equals("000000")){
                            log.error("没有获得条码",barcode);
                            continue;
                        }
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
                        locTypeDto.setLocType1((short)1);
                        SearchLocParam param = new SearchLocParam();
@@ -189,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")
@@ -205,85 +233,28 @@
                            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"))){
                            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));
                            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);
                        }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));
                            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();
                    }
@@ -340,7 +311,7 @@
                            log.error("更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
                        }
                    } else {
                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                        News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    }

                }
@@ -510,6 +481,7 @@
                    }
                    // 判断工作档条件
                    if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) {
                        News.error("工作档案条件不满足：工作档案："+wrkMast+";条件iotype<100或者staNo为空或者sourceStaNo为空");
                        continue;
                    }
                    // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
@@ -540,7 +512,7 @@
                            // 复位堆垛机
                            crnThread.setResetFlag(true);
                        } else {
                            log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                            News.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                        }

                    }
@@ -561,7 +533,7 @@
            if (crnProtocol == null) { continue; }
            BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
            if (basCrnp == null) {
                log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
                News.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
                continue;
            }

@@ -677,7 +649,7 @@
            // 查询站点详细信息
            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()
@@ -696,11 +668,11 @@
            // 获取库位信息
            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;
            }

@@ -722,12 +694,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;
                    }
@@ -765,9 +737,12 @@
            crnCommand.setDestinationPosY(locMast.getBay1().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) {
@@ -782,13 +757,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);
            }
        }
    }
@@ -808,13 +787,13 @@
                }
                // 工作档状态判断
                if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null){
                    log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
                    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());
                    News.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
                    continue;
                }
                // 获取堆垛机出库站信息
@@ -833,7 +812,7 @@
                // 查询站点详细信息
                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                if (staDetl == null) {
                    log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    News.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    break;
//                    continue;
                }
@@ -842,66 +821,16 @@
                        .eq("loc_sts","R")
                        .eq("loc_no",wrkMast.getSourceLocNo()));
                if(Cools.isEmpty(locMast)){
                    log.error("出库 ===>> 库位中没有这笔资料",wrkMast.getSourceLocNo());
                    News.error("出库 ===>> 库位中没有这笔资料",wrkMast.getSourceLocNo());
                    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){
                        log.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) {
                                log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                            } else {
                                if(waitWrkMast.getWrkSts() == 11) {
                                    waitWrkMast.setIoPri(15D);
                                    waitWrkMast.setModiTime(new Date());
                                    if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                        log.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);
                            }
                            log.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;
                            }
                        }
                    }

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


                    // 1.堆垛机开始移动
                    CrnCommand crnCommand = new CrnCommand();
@@ -925,7 +853,7 @@
                    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();
@@ -933,9 +861,101 @@
                        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;
                    }
                }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;
                        }
                    }
                }
            }
@@ -1063,26 +1083,42 @@
     * 库位移转
     */
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
//        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) {
            if(wm.getMk().equals('Y')){
                wrkMast=wm;
                break;
            LocMast sourceSta1 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no",wm.getSourceLocNo()));
            if (!Cools.isEmpty(sourceSta1.getCtnKind())){
                if(sourceSta1.getCtnKind()==1){
                    wrkMast=wm;
                    break;
                }
            }
        }
        //后查等待库位转测试库位
        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;
        }
        // 源库位  库位状态判断
@@ -1092,7 +1128,7 @@
        // 获取目标库位信息
        LocMast sta = locMastService.selectById(wrkMast.getLocNo());
        if (null == sta) {
            log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            News.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            return;
        }
        // 获取堆垛机信息 并 判断是否可入出
@@ -1113,7 +1149,7 @@

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

@@ -1135,7 +1171,7 @@
            crnCommand.setFireStaut((short) 1);
        }
        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();
@@ -1143,9 +1179,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("结束移库任务程序");

    }

@@ -1168,7 +1205,7 @@
                    // 获取入库待确认工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep3(crnProtocol.getTaskNo().intValue());
                    if (wrkMast == null) {
                        log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        continue;
                    }
                    // 入库 + 库位转移  ==> 4.入库完成
@@ -1437,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());
@@ -1448,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;
@@ -1479,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线程
@@ -1500,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);
                }
            }

@@ -1579,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());
                }
            }
        }
@@ -1904,15 +1969,15 @@
                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) {
@@ -1922,9 +1987,9 @@
                    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());
                }


@@ -1998,7 +2063,7 @@
            // 查询站点详细信息
            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()
@@ -2043,7 +2108,7 @@
            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 {
            }
        }
@@ -2309,17 +2374,18 @@
                if (!Cools.isEmpty(locMast)){
                    //报警信号写入1
                    if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(4, 1))) {
                        log.error("火警  ===>> 给堆垛机发送报警信号失败");
                        News.error("火警  ===>> 给堆垛机发送报警信号失败");
                    }
                    News.error("火警!!!!!!!  ===>> 给堆垛机发送报警信号成功");
                } else {
                    //报警信号没有后，复位地址
                    if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(4, 0))) {
                        log.error("火警  ===>> 给堆垛机清零复位报警信号失败");
                        News.error("火警  ===>> 给堆垛机清零复位报警信号失败");
                    }
                }
            }
        } catch (Exception e) {
            log.error("火警  ===>> 给堆垛机发送警报失败", e);
            News.error("火警  ===>> 给堆垛机发送警报失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
@@ -2335,18 +2401,18 @@
            for (DevpSlave devp : slaveProperties.getDevp()) {
                BasDevp basDevp = basDevpService.selectOne(new EntityWrapper<BasDevp>().eq("dev_no",103));
                if (Cools.isEmpty(basDevp)){
                    log.error("103站点查询失败-MainServiceImpl.java-2255行");
                    News.error("103站点查询失败-MainServiceImpl.java-2255行");
                }
                if (basDevp.getAutoing().equals("Y") && basDevp.getWrkNo()>0 && basDevp.getLoading().equals("Y") ){
                    WrkDetl wrkDetl = wrkDetlService.devpPackNo(basDevp.getWrkNo());
                    if (Cools.isEmpty(wrkDetl)){
                        log.error("103站点查询失败-MainServiceImpl.java-2255行");
                        News.error("103站点查询失败-MainServiceImpl.java-2255行");
                    }
                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4,wrkDetl.getMatnr()));
                }
            }
        } catch (Exception e) {
            log.error("103  ===>> 给输送线发送Pack码失败", e);
            News.error("103  ===>> 给输送线发送Pack码失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
@@ -2359,19 +2425,24 @@
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                log.info("2363行程序开始运行");
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                if(null != devpThread){
                    for (int i = 0; i < 48; i++){
//                        log.info("2367行程序开始运行，第"+i+"次");
                        boolean fig=false;
                        //查询在库和预约出库
                        LocMast locMast=locMastService.selectztgx("F","R",i);
                        if(!Cools.isEmpty(locMast)){
//                            log.info("2372行程序开始运行，查询测试档");
                            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;
                            }
//                            log.info("2380行程序开始运行，测试档不为空，下一步");
                            //devpThread.startSignal[i][0]
                            //0:空,1:启动中,2:工作中,3:自动暂停,4:正常完成(OK),5:异常停止(NG),6:在线,7:离线,8:空闲

@@ -2381,35 +2452,45 @@
                            //testMast.setStatus
                            //"状态 0: 待申请  1: 申请中  2: 已复核 3:测试中 4:完成 5:移库 6:火警"
                            if(devpThread.startSignal[i][0]==8){
                                News.info("2390行程序开始运行，修改测试档状态为 1、申请中，开始修改前："+ JSON.toJSONString(testMast));
                                testMast.setStatus(1);
                                locMast.setPackStatus(1);
                                testMast.setModiTime(new Date());
                                log.info("2394行程序开始运行，修改测试档状态为 1、申请中,修改数据后、未更新"+JSON.toJSONString(testMast));
                            }else if(devpThread.startSignal[i][0]==2 && locMast.getPackStatus()!=2){
                                News.info("2396行程序开始运行，修改测试档状态为 3、测试中，开始修改前："+JSON.toJSONString(testMast));
                                testMast.setStatus(3);
                                locMast.setPackStatus(2);
                                testMast.setModiTime(new Date());
                                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）任务档，"+JSON.toJSONString(wrkMast));
                                if(!Cools.isEmpty(wrkMast)){
                                    if(wrkMast.getWrkSts()==11){
                                    if(wrkMast.getIoType()==11){
                                        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()));
                                        if(wrkMast.getIoType()==11){
                                            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，删除工作档"+JSON.toJSONString(wrkMast)+JSON.toJSONString(locMast));
                                        locMast.setLocSts("F");
                                        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()+JSON.toJSONString(locMast));
                                        }else{
                                            log.error("2424修改测试库位状态成功"+locMast.getLocNo()+JSON.toJSONString(locMast));
                                            fig=true;
                                        }
                                    }
                                    wrkMastMapper.delete(new EntityWrapper<WrkMast>()
                                                .eq("wrk_no",wrkMast.getWrkNo()));
                                    locMast.setLocSts("F");
                                    wrkDetlService.delete(new EntityWrapper<WrkDetl>().eq("wrk_no",wrkMast.getWrkNo()));
                                    if(!locMastService.update(locMast,new EntityWrapper<LocMast>()
                                            .eq("channel",i+1))){
                                        log.error("修改测试库位状态失败"+locMast.getLocNo(),locMast);
                                    }else{
                                        fig=true;
                                    }
                                }}
                                }
                            }else if(devpThread.startSignal[i][0]==3){
                                locMast.setPackStatus(7);
                                testMast.setModiTime(new Date());
@@ -2430,31 +2511,23 @@
                            //通道启动按钮状态，1:可以启动出库或者移库，0:不能启动出库或者移库
                            locMast.setCtnKind(devpThread.startSignal[i][2]);
                            if(devpThread.startSignal[i][2]==1){
                                WrkMast wrkMast=wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("source_loc_no",locMast.getLocNo()));
                                if(!Cools.isEmpty(wrkMast)){
                                    wrkMast.setMk("Y");
                                    if(!wrkMastService.update(wrkMast,new EntityWrapper<WrkMast>()
                                            .eq("source_loc_no",locMast.getLocNo()))){
                                        log.error("修改任务档启动按钮状态，任务档状态失败"+wrkMast.getSourceLocNo(),wrkMast);
                                    }
                                }
                                if(!locMastService.update(locMast,new EntityWrapper<LocMast>()
                                        .eq("loc_sts","R")
                                        .eq("channel",i+1))){
                                    log.error("修改启动按钮状态，测试库位状态失败"+locMast.getLocNo(),locMast);
                                    News.error("修改启动按钮状态，测试库位状态失败"+locMast.getLocNo(),locMast);
                                }
                            }else if(!locMast.getLocSts().equals("R")){
                                if(!fig){
                                    if(!locMastService.update(locMast,new EntityWrapper<LocMast>()
                                            .eq("loc_sts","F")
                                            .eq("channel",i+1))){
                                        log.error("修改测试库位状态失败"+locMast.getLocNo(),locMast);
                                        News.error("修改测试库位状态失败"+locMast.getLocNo(),locMast);
                                    }
                                }
                                if(!testMastService.update(testMast,new EntityWrapper<TestMast>()
                                        .eq("loc_no",locMast.getLocNo())
                                        .eq("user_id",locMast.getBarcode()))) {
                                    log.error("修改测试档状态失败" + locMast.getLocNo(), locMast);
                                    News.error("修改测试档状态失败" + locMast.getLocNo(), locMast);
                                }
                            }
                        }
@@ -2482,12 +2555,12 @@
                                    if(!testMastService.update(testMast,new EntityWrapper<TestMast>()
                                            .eq("loc_no",locMast.getLocNo())
                                            .eq("user_id",locMast.getBarcode()))) {
                                        log.error("修改测试档状态失败" + locMast.getLocNo(), locMast);
                                        News.error("修改测试档状态失败" + locMast.getLocNo(), locMast);
                                    }
                                }
                            }
                        }catch (Exception e){
                            log.error("火警  ===>> 给输送线发送警报失败,通道号：", i+1);
                            News.error("火警  ===>> 给输送线发送警报失败,通道号：", i+1);
                        }
                    }

@@ -2497,7 +2570,7 @@

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