完善移库任务自动下发

野心家

2024-07-16 40c2987c083122db0c9f9ea57750abb42d85b642

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

@@ -19,6 +19,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;
@@ -35,20 +36,24 @@
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.BarcodeThread;
import com.zy.core.thread.LedThread;
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.stream.Collectors;


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

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

    /**
     * 组托
@@ -103,7 +110,6 @@
        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) {
@@ -128,10 +134,9 @@
                } else {
                    staProtocol = staProtocol.clone();
                }

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

                // 判断是否满足入库条件
                if (staProtocol.isAutoing() && staProtocol.isLoading()
                        && staProtocol.isInEnable()
@@ -152,9 +157,9 @@
//                    }

                    // 判断重复工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode);
                    WrkMast wrkMast = wrkMastMapper.selectPakInStep1(inSta.getStaNo(), barcode.substring(0,6));
                    if (wrkMast != null) {
                        log.error("工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={}", wrkMast.getWrkNo());
                        News.error("工作档中已存在该站状态为（ 2.设备上走 ）的数据,工作号={}", wrkMast.getWrkNo());
                        continue;
                    }
//                    // 获取入库通知档
@@ -165,7 +170,20 @@
//                    }

                    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();
@@ -173,6 +191,7 @@
                        param.setIoType(1);
                        param.setSourceStaNo(inSta.getStaNo());
                        param.setLocType1(locTypeDto.getLocType1());
                        param.setPackNo(pack);
                        String response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath("/rpc/pakin/loc/v1")
@@ -182,17 +201,31 @@
                        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 {
                            log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                        } 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);
                            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);
                            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);
                        }


@@ -254,6 +287,7 @@
//                        }

                    } catch (Exception e) {
                        News.error("扫码入库报错，错误信息",e);
                        e.printStackTrace();
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    }
@@ -310,7 +344,7 @@
                            log.error("更新工作档失败！！！ [工作号：{}]", wrkMast.getWrkNo());
                        }
                    } else {
                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                        News.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    }

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

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

@@ -647,7 +682,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()
@@ -666,11 +701,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;
            }

@@ -692,12 +727,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;
                    }
@@ -733,10 +768,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) {
@@ -751,13 +790,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);
            }
        }
    }
@@ -777,13 +820,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;
                }
                // 获取堆垛机出库站信息
@@ -802,13 +845,28 @@
                // 查询站点详细信息
                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")
                        && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
                    //测试库位出库必须要按启动按钮才能出库
                    if((wrkMast.getStaNo()==206 || wrkMast.getStaNo()==1000)&& locMast.getCtnKind()==0){
                        News.error("出库 ===>> 等待启动出库按钮",wrkMast);
                        continue;
                    }
                    // 命令下发区 --------------------------------------------------------------------------

                    // 堆垛机控制过滤
@@ -825,13 +883,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) {
                                    waitWrkMast.setIoPri(15D);
                                    waitWrkMast.setModiTime(new Date());
                                    if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                        log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                        News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                    }
                                    continue;
                                } else {
@@ -848,7 +906,7 @@
                                // 生成工作档,将浅库位移转到新的库位中
                                moveLocForDeepLoc(slave, shallowLoc);
                            }
                            log.error("{}任务出库失败，浅库位堵塞！", wrkMast.getWrkNo());
                            News.error("{}任务出库失败，浅库位堵塞！", wrkMast.getWrkNo());
                            continue;
                        } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")){
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
@@ -864,6 +922,7 @@
//                        return;
                    }


                    // 1.堆垛机开始移动
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
@@ -876,8 +935,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();
@@ -885,7 +945,7 @@
                        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;
                    }
@@ -1015,15 +1075,42 @@
     * 库位移转
     */
    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;
        }
        //先查测试库位转OK或者NG库位按了按钮的
        for (WrkMast wm: wrkMasts) {
            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;
        }
        // 源库位  库位状态判断
@@ -1033,7 +1120,7 @@
        // 获取目标库位信息
        LocMast sta = locMastService.selectById(wrkMast.getLocNo());
        if (null == sta) {
            log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            News.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            return;
        }
        // 获取堆垛机信息 并 判断是否可入出
@@ -1052,6 +1139,12 @@
            return;
        }

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

        // 命令下发区 --------------------------------------------------------------------------
        CrnCommand crnCommand = new CrnCommand();
        crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
@@ -1064,8 +1157,13 @@
        crnCommand.setDestinationPosX(sta.getRow1().shortValue());     // 目标库位排
        crnCommand.setDestinationPosY(sta.getBay1().shortValue());     // 目标库位列
        crnCommand.setDestinationPosZ(sta.getLev1().shortValue());     // 目标库位层
        if(!sta.getLocNo().equals("0102501")){
            crnCommand.setBarcode(wrkMast.getBarcode());//托盘码
        }else {
            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();
@@ -1073,9 +1171,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("结束移库任务程序");

    }

@@ -1098,7 +1197,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.入库完成
@@ -1834,15 +1933,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) {
@@ -1852,9 +1951,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());
                }


@@ -1928,7 +2027,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()
@@ -1973,7 +2072,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 {
            }
        }
@@ -1993,102 +2092,207 @@
                        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
                        switch (devpThread.startSignal[i][0]){//根据信号查找testMast表中对应状态条件,olsStatus，newStatus根据实际流程调整
                            case 0://初始状态，入库
                                olsStatus = 1;//待测
                                newStatus = 1;//待测
                                newSingle = 1;//库存有资料，寄存器地址，0===>>1
                                break;
                            case 3://完成测试信号
                                olsStatus = 3;
                                newStatus = 4;
                                newSingle = 0;//测试完成，寄存器地址清零，3===>>0
                            case 2://启动复核信号
                                olsStatus = 1;//待测
                                newStatus = 2;//复核中
                                newSingle = 3;//测试复核，寄存器地址，2===>>3
                                break;
                            case 5://暂停信号
                            case 3://测试完成
                                olsStatus = 4;//测试完成
                                newStatus = 4;//测试完成
                                newSingle = 4;//（NG:4\OK:41）测试完成，寄存器地址，3===>>4\41
                                break;
                            case 5://NG测试信号
                            case 6://完成测试信号
                            case 22://完成测试信号
                                olsStatus = 4;//测试完成
                                newStatus = 5;//已移库
                                newSingle = 0;//启动移库，寄存器地址清零，5/6===>>0
                                break;
                            case 7://暂停信号
                                olsStatus = 99;//plc给出暂停信号
                                newStatus = 0;//WCS收到暂停信号后，更新testMast
                                newSingle = 6;//暂停测试，寄存器地址，5===>>6
                                newSingle = 8;//暂停测试，寄存器地址，7===>>8
                                break;
                            case 7://紧急出库确认充电线已经拔出
                            case 9://紧急出库确认充电线已经拔出
                                olsStatus = 99;//plc给出暂停信号
                                newStatus = 0;//WCS收到暂停信号后，更新testMast
                                newSingle = 6;//暂停测试，寄存器地址，7===>>6
                                newSingle = 8;//暂停测试，寄存器地址，9===>>8
                                break;
                            case 8://解除暂停
                                olsStatus = 99;
                                newStatus = 0;
                                newSingle = 0;//测试复核，寄存器地址，8===>>0
                            case 10://解除暂停信号
                                olsStatus = 0;//plc给出暂停信号
                                newStatus = 1;//WCS收到暂停信号后，更新testMast
                                newSingle = 0;//暂停测试，寄存器地址，10===>>0/11
                                break;
                            case 12://紧急出库确认充电线已经拔出
                                newSingle = 11;//暂停测试，寄存器地址，12===>>11
                                break;
                            case 13://入库前判断充电线是否放好
                                newSingle = 14;//禁用库位，寄存器地址，13===>>14
                                break;
                            case 15://充电线放好
                                newSingle = 0;//复位，寄存器地址，12===>>0
                                break;
                            default:
                                log.info("读取通道"+(i+1)+"测试库位按钮信号:为"+devpThread.startSignal[i][0]);
                                continue;
                        }

                        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));
                        LocMast locMast=null;
                        boolean sign=false;
                        switch (devpThread.startSignal[i][0]){
                            case 0:
                                if (!Cools.isEmpty(testMast)){
                                    locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
                                    if (!Cools.isEmpty(locMast) && locMast.getLocSts().equals("F")){
                                        sign=true;
                                    }
                                }
                                break;
                            case 3:
                                if (!Cools.isEmpty(testMast)){
                                    locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
                                    if (!Cools.isEmpty(locMast) && locMast.getLocSts().equals("F")){
                                        sign=true;
                                        if (locMast.getPackStatus()==3){//测试完成
                                            newSingle=41;
                                        }else if (locMast.getPackStatus()==4){//测试失败
                                            newSingle=4;
                                        }else {
                                            log.info("读取通道"+(i+1)+"测试库位按钮信号:为"+devpThread.startSignal[i][0]+"通道库位pack状态信息异常"+locMast.getPackStatus());
                                            sign=false;
                                        }
                                    }
                                }
                                break;
                            case 5:
                            case 6:
                                if (!Cools.isEmpty(testMast)){
                                    locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
                                    if (!Cools.isEmpty(locMast) && locMast.getLocSts().equals("F")){
                                        if (devpThread.startSignal[i][0]==5 && locMast.getPackStatus()==4){
                                            sign=true;
                                        }else if (devpThread.startSignal[i][0]==6 && locMast.getPackStatus()==3){
                                            sign=true;
                                        }else {
                                            log.error("测试完成移库时按下完成按钮与测试结果不一致===>>[channel:{}", i+1);
                                        }
                                    }else {
                                        log.error("测试完成移库时未查询到测试档案===>>[channel:{}", i+1);
                                    }
                                }
                                break;
                            case 2:
                                if (!Cools.isEmpty(testMast)){
                                    testMast.setStatus(newStatus);
                                    testMast.setModiTime(new Date());
                                    if(!testMastService.update(testMast,new EntityWrapper<TestMast>().eq("channel",(i+1)).eq("barcode",testMast.getBarcode()))){
                                        throw new CoolException("更新产品测试状态失败");
                                    }else {
                                        sign=true;
                                    }
                                }else {
                                    log.error("启动测试时未查询到测试档案===>>[channel:{}", i+1);
                                }
                                break;
                            case 7:
                                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)) {
                                    testMast = testMastService.selectOne(new EntityWrapper<TestMast>().eq("channel",(i+1)));
                                    testMast.setStatus(newStatus);
                                    testMast.setModiTime(new Date());
                                    if(!testMastService.update(testMast,new EntityWrapper<TestMast>().eq("channel",(i+1)).eq("barcode",testMast.getBarcode()))){
                                        log.error("更新产品测试状态失败");
                                    }
                                    sign=true;
                                } else {
                                    log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/mobile/test/suspend/auth", JSON.toJSONString(param), response);
                                }
                                break;
                            case 9:
                            case 12:
                                locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
                                if (!Cools.isEmpty(locMast) && locMast.getLocSts().equals("F") || locMast.getLocSts().equals("D")){
                                    locMast.setPackStatus(8); //8.紧急出库
                                    if (locMastService.update(locMast,new EntityWrapper<LocMast>().eq("channel",(i+1)))){
                                        log.info("库位：{}，紧急出库！",locMast.getLocNo());
                                    }
                                }else {
                                    log.error("库位不是在库状态，无需紧急出库！");
                                }
                                sign=true;
                                break;
                            case 10:
                                if (!Cools.isEmpty(testMast)){
                                    locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
                                    if (!Cools.isEmpty(locMast) && locMast.getLocSts().equals("F") ){
                                        if ( locMast.getFireStatus().equals(1)){
                                            newSingle=11;
                                        }else {
                                            testMast.setStatus(newStatus);
                                            testMast.setModiTime(new Date());
                                            if(!testMastService.update(testMast,new EntityWrapper<TestMast>().eq("channel",(i+1)).eq("barcode",testMast.getBarcode()))){
                                                throw new CoolException("更新产品测试状态失败");
                                            }else {
                                                sign=true;
                                            }
                                        }
                                    }
                                }
                                sign=true;
                                break;
                            case 13:
                                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)));
                                }
                                sign=true;
                                break;
                            case 15:
                                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)));
                                }
                                sign=true;
                                break;
                            default:
                                log.info("读取通道"+(i+1)+"测试库位按钮信号:为"+devpThread.startSignal[i][0]);
                                continue;
                        }
                        if (sign){
                            boolean result = messageQueueOffer(i,newSingle,SlaveType.Devp, devp.getId());
                            if(!result){
                                log.error("更新测试信号失败===>>[channel:{},locNo:{},barcode:{}]", i+1, testMast.getLocNo(), testMast.getBarcode());
//                                throw new CoolException("更新测试信号失败===>>" + i);
                            } else {
                                devpThread.startSignal[i] = newSingle;
                                devpThread.startSignal[i][0]  = newSingle;
                            }
                        }else if (devpThread.startSignal[i] == 5){
                            SearchLocParam param = new SearchLocParam();
                            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(7); //7.紧急出库
                                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){

                        }

                        try{
                            locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",(i+1)));
                            if(devpThread.startSignal[i][1]!=locMast.getFireStatus()){
                                messageQueueOffer2(i+1,(short)((int)locMast.getFireStatus()),SlaveType.Devp, devp.getId());
                            }
                        }catch (Exception e){
                            log.error("火警  ===>> 给输送线发送警报失败,通道号：", i+1);
                        }
                    }

                }
@@ -2101,4 +2305,238 @@
        }
    }

    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中
     */
    @Transactional
    public void fierCrn() {
        try {
            for (CrnSlave crn :slaveProperties.getCrn()) {
                if(crn.getId()!=1){
                    continue;
                }
                // 获取堆垛机信息
                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, 1))) {
                        News.error("火警  ===>> 给堆垛机发送报警信号失败");
                    }
                    News.error("火警!!!!!!!  ===>> 给堆垛机发送报警信号成功");
                } else {
                    //报警信号没有后，复位地址
                    if (!MessageQueue.offer(SlaveType.Crn, 1, new Task(4, 0))) {
                        News.error("火警  ===>> 给堆垛机清零复位报警信号失败");
                    }
                }
            }
        } catch (Exception e) {
            News.error("火警  ===>> 给堆垛机发送警报失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

    /**
     * 103站点有物下发pack码
     */
    @Transactional
    public void packDevp() {
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                BasDevp basDevp = basDevpService.selectOne(new EntityWrapper<BasDevp>().eq("dev_no",103));
                if (Cools.isEmpty(basDevp)){
                    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)){
                        News.error("103站点查询失败-MainServiceImpl.java-2255行");
                    }
                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(4,wrkDetl.getMatnr()));
                }
            }
        } catch (Exception e) {
            News.error("103  ===>> 给输送线发送Pack码失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }
    /**
     * 根据PLC按钮测试、完成、暂停信号，更新testMast表中status值，交由WMS系统处理
     */
    @Transactional
    public void packTest1() {
        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:空闲

                            //locMast.setPackStatus
                            // "产品状态{0:无,1:待测,2:测试中;3.测试完成;4.测试失败;5.静置中;6:静置完成;7:暂停测试;8:紧急出库;9:在线;10:离线;11:空闲;}"

                            //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){
                                            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;
                                        }
                                    }
                                }
                            }else if(devpThread.startSignal[i][0]==3){
                                locMast.setPackStatus(7);
                                testMast.setModiTime(new Date());
                            }else if(devpThread.startSignal[i][0]==4 && testMast.getStatus()!=4&&locMast.getFireStatus()!=1&&testMast.getStatus()!=6){
                                locMast.setPackStatus(3);
                                testMast.setStatus(4);
                                testMast.setModiTime(new Date());
                                testMastService.insertPackQualified(true,new Date(),testMast.getBarcode());
                            }else if(devpThread.startSignal[i][0]==5 && testMast.getStatus()!=4&&locMast.getFireStatus()!=1&&testMast.getStatus()!=6){
                                locMast.setPackStatus(4);
                                testMast.setStatus(4);
                                testMast.setModiTime(new Date());
                                testMastService.insertPackQualified(false,new Date(),testMast.getBarcode());
                            }
//                            else if(devpThread.startSignal[i][0]==6||devpThread.startSignal[i][0]==7||devpThread.startSignal[i][0]==8){
//                                locMast.setPackStatus(devpThread.startSignal[i][0]+3);
//                            }
                            //通道启动按钮状态，1:可以启动出库或者移库，0:不能启动出库或者移库
                            locMast.setCtnKind(devpThread.startSignal[i][2]);
                            if(devpThread.startSignal[i][2]==1){
                                if(!locMastService.update(locMast,new EntityWrapper<LocMast>()
                                        .eq("loc_sts","R")
                                        .eq("channel",i+1))){
                                    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))){
                                        News.error("修改测试库位状态失败"+locMast.getLocNo(),locMast);
                                    }
                                }
                                if(!testMastService.update(testMast,new EntityWrapper<TestMast>()
                                        .eq("loc_no",locMast.getLocNo())
                                        .eq("user_id",locMast.getBarcode()))) {
                                    News.error("修改测试档状态失败" + locMast.getLocNo(), locMast);
                                }
                            }
                        }
                    }
                    //当充放电库位为O空库位时
                    //库位状态改为8空闲
                    //给PLC写消防信号
                    for (int i=0;i<48;i++){
                        LocMast locMast=locMastService.selectOne(new EntityWrapper<LocMast>().eq("channel",i+1));
                        TestMast testMast=testMastService.selectOne(new EntityWrapper<TestMast>()
                                .eq("loc_no",locMast.getLocNo())
                                .eq("user_id",locMast.getBarcode()));
                        if((locMast.getLocSts().equals("O")||locMast.getLocSts().equals("S"))&&devpThread.startSignal[i][0]!=8){
                            Thread.sleep(1000);
                            MessageQueue.offer(SlaveType.Devp, 1, new Task(6,locMast.getChannel()-1));
                        }
                        try{
                            if(locMast.getFireStatus()!=devpThread.startSignal[i][1]){
                                messageQueueOffer2(i,(short)((int)locMast.getFireStatus()),SlaveType.Devp, devp.getId());
                                if(Cools.isEmpty(testMast)){
                                    continue;
                                }
                                if(locMast.getFireStatus()==1){
                                    testMast.setStatus(6);//火警
                                    if(!testMastService.update(testMast,new EntityWrapper<TestMast>()
                                            .eq("loc_no",locMast.getLocNo())
                                            .eq("user_id",locMast.getBarcode()))) {
                                        News.error("修改测试档状态失败" + locMast.getLocNo(), locMast);
                                    }
                                }
                            }
                        }catch (Exception e){
                            News.error("火警  ===>> 给输送线发送警报失败,通道号：", i+1);
                        }
                    }



                }

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