*

lsh

2 天以前 808d32829a61f6f1de0b989b2c818327d3bf74ef

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

@@ -155,13 +155,13 @@
                    }
                    // 退回
                    if (back) {
                        if (stano == inSta.getBackSta().shortValue()){
                        if (stano == inSta.getBackSta().shortValue()) {
                            continue;
                        }
                        if (workNo == 0 && stano == 0){
                        if (workNo == 0 && stano == 0) {
                            continue;
                        }
                        if (!staProtocol.isPakMk()){
                        if (!staProtocol.isPakMk()) {
                            continue;
                        }
//                        News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
@@ -180,27 +180,30 @@
                    // 判断是否满足入库条件
                    if (staProtocol.isAutoing() && staProtocol.isLoading()
                            && staProtocol.isInEnable()
                            && !staProtocol.isEmptyMk() && (workNo == 9991 )
                            && staProtocol.isPakMk()) {
                            && !staProtocol.isEmptyMk() && (workNo == 0 || (workNo>9000 && workNo<10000))
                            && staProtocol.isPakMk()
                            && staProtocol.isPakMkWalk()
                    ) {
                        // 获取条码扫描仪信息
                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
                        if (barcodeThread == null) {
                            continue;
                        }
                        String barcode = barcodeThread.getBarcode();
                        if(!Cools.isEmpty(barcode) && !barcode.equals("99999999")) {
                        if (!Cools.isEmpty(barcode) && !barcode.equals("99999999")) {
                            // 请求wms接口，获取工作号和目标库位
                            ToWmsDTO toWmsDTO = new ToWmsDTO(barcode,staProtocol.getSiteId(),staProtocol.isHigh() ? 2 : 1);
                            TaskWrk taskWrk1=taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode",barcode));
                            if(!Cools.isEmpty(taskWrk1)){
                                log.info("托盘码："+barcode+"任务档存在");
                                if (taskWrk1.getIoType()==1 && taskWrk1.getStartPoint().equals(staProtocol.getSiteId().toString())){
                            ToWmsDTO toWmsDTO = new ToWmsDTO(barcode, staProtocol.getSiteId(), 0);
                            TaskWrk taskWrk1 = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", barcode));
                            if (!Cools.isEmpty(taskWrk1)) {
                                log.info("托盘码：" + barcode + "任务档存在");
                                if (taskWrk1.getIoType() == 1 && taskWrk1.getStartPoint().equals(staProtocol.getSiteId().toString())) {
                                    StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                                            .eq("crn_no", taskWrk1.getCrnNo()).eq("type_no",1).eq("stn_no",staProtocol.getSiteId()));
                                    if (Cools.isEmpty(staDesc)){
                                        log.info("托盘码："+barcode+"任务档存在");
                                            .eq("CRN_NO", taskWrk1.getCrnNo()).eq("TYPE_NO", 1).eq("STN_NO", staProtocol.getSiteId()));

                                    if (Cools.isEmpty(staDesc)) {
                                        log.info("托盘码：" + barcode + "任务档存在");
                                        return;
                                    }else {
                                    } else {
                                        staProtocol.setWorkNo(taskWrk1.getWrkNo());
                                        staProtocol.setStaNo(staDesc.getCrnStn());
                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
@@ -209,9 +212,9 @@
                                return;
                            }
                            HashMap<String, Object> headParam = new HashMap<>();
                            headParam.put("Content-Type","application/json");
                            headParam.put("Content-Type", "application/json");
                            String response;
                            try{
                            try {
                                response = new HttpHandler.Builder()
                                        // .setHeaders(headParam)
                                        .setUri(wmsUrl)
@@ -219,140 +222,54 @@
                                        .setJson(JSON.toJSONString(toWmsDTO))
                                        .build()
                                        .doPost();
                            }catch (Exception e){
                            } catch (Exception e) {
                                log.error("请求入库调用接口失败");
                                log.error("异常信息打印："+e);
                                try{
                                log.error("异常信息打印：" + e);
                                try {
                                    BasDevp basDevp = basDevpService.selectById(inSta.getStaNo());
                                    if (Cools.isEmpty(basDevp)){
                                        log.error("站点号异常"+inSta.getStaNo());
                                    } else if (basDevp.getStaErr()!=0){
                                    if (Cools.isEmpty(basDevp)) {
                                        log.error("站点号异常" + inSta.getStaNo());
                                    } else if (basDevp.getStaErr() != 0) {
                                        basDevp.setStaErr(2);
                                        basDevpService.updateById(basDevp);
                                    }
                                }catch (Exception e1){
                                } catch (Exception e1) {
                                    // 退回
                                    log.error("扫码检测程序异常"+inSta.getStaNo()+"异常信息"+e1);
                                    log.error("扫码检测程序异常" + inSta.getStaNo() + "异常信息" + e1);
                                }
                                staProtocol.setWorkNo(9999);
                                staProtocol.setStaNo(inSta.getStaNo());
                                devpThread.setPakMk(staProtocol.getSiteId(), false);
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                                    TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
//                                    if (taskWrk != null) {
//                                        taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
//                                        taskWrkMapper.updateById(taskWrk);
//                                    }
                                continue;
                            }

                            JSONObject jsonObject = JSON.parseObject(response);
                            apiLogService.save("wms请求入库货位接口"
                                    ,wmsUrl+inboundTaskApplyPath
                                    ,null
                                    ,"127.0.0.1"
                                    ,JSON.toJSONString(toWmsDTO)
                                    ,response
                                    ,true
                                    , wmsUrl + inboundTaskApplyPath
                                    , null
                                    , "127.0.0.1"
                                    , JSON.toJSONString(toWmsDTO)
                                    , response
                                    , true
                            );
                            log.info("入库请求参数{}" + JSON.toJSONString(toWmsDTO));
                            log.info("入库请求返回参数{}" + JSON.toJSONString(response));
                            if (jsonObject.getInteger("code").equals(200) && !Cools.isEmpty(jsonObject.get("data").toString())) {
                                GetWmsDto getWmsDto = JSON.parseObject(jsonObject.get("data").toString(), GetWmsDto.class);
                                try{
                                    BasDevp basDevp = basDevpService.selectById(inSta.getStaNo());
                                    if (Cools.isEmpty(basDevp)){
                                        log.error("站点号异常1"+inSta.getStaNo());
                                        throw new CoolException("站点号异常1,未查询到站点信息"+inSta.getStaNo());
                                    }
                                    Integer staNoCrnNo = Utils.StaNoCrnNo(inSta.getStaNo());
                                    if (staNoCrnNo==0){
                                        basDevp.setStaErr(1);
                                        basDevpService.updateById(basDevp);
                                        log.error("站点号异常2"+inSta.getStaNo());
                                        throw new CoolException("站点号异常2,站点号不存在"+inSta.getStaNo());
                                    }else {
                                        LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                                                .eq("crn_no", staNoCrnNo.longValue())
                                                .eq("loc_no", getWmsDto.getLocNo()));
                                        if (Cools.isEmpty(locMast)){
                                            basDevp.setStaErr(1);
                                            basDevpService.updateById(basDevp);
                                            log.error("站点号异常3"+inSta.getStaNo());
                                            throw new CoolException("站点号异常3：此巷道不存在目标库位"+inSta.getStaNo());
                                        }
                                    }
                                } catch (Exception e){
//                                    log.error("扫码检测程序异常"+inSta.getStaNo()+"异常信息"+e);
                            if (jsonObject.getInteger("code").equals(200)) {
                                try {
                                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                                } catch (Exception e) {
                                    // 退回
                                    log.error("扫码检测程序异常"+inSta.getStaNo()+errMsg);
                                    log.error("扫码检测程序异常,异常信息"+e);
                                    log.error("扫码检测程序异常" + inSta.getStaNo() + errMsg);
                                    log.error("扫码检测程序异常,异常信息" + e);

                                    staProtocol.setWorkNo(9999);
                                    staProtocol.setStaNo(inSta.getStaNo());
                                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                                    TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
//                                    if (taskWrk != null) {
//                                        taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
//                                        taskWrkMapper.updateById(taskWrk);
//                                    }
                                    continue;
                                }
                                //查看该库位是否为空库位
                                LocMast locMast=locMastService.selectOne(new EntityWrapper<LocMast>()
                                        .eq("loc_sts","O")
                                        .eq("loc_no",getWmsDto.getLocNo()));
                                if(Cools.isEmpty(locMast)){
                                    try{
                                        HashMap<String, Object> headParam1 = new HashMap<>();
                                        headParam1.put("taskNo",getWmsDto.getTaskNo());
                                        headParam1.put("status",6);
                                        headParam1.put("ioType",1);
                                        headParam1.put("barcode",barcode);
                                        String response2;
                                        response2 = new HttpHandler.Builder()
                                                // .setHeaders(headParam)
                                                .setUri(wmsUrl)
                                                .setPath(taskStatusFeedbackPath)
                                                .setJson(JSON.toJSONString(headParam1))
                                                .build()
                                                .doPost();
                                        JSONObject jsonObject1 = JSON.parseObject(response2);
                                        apiLogService.save("wcs派发库位==》不为空《==上报wms"
                                                ,wmsUrl+taskStatusFeedbackPath
                                                ,null
                                                ,"127.0.0.1"
                                                ,JSON.toJSONString(headParam1)
                                                ,response
                                                ,true
                                        );
                                    }catch (Exception e){
                                        log.error("wcs派发库位==》不为空《==上报wms", getWmsDto.getWrkNo());
                                        throw new CoolException("wcs派发入库任务上报wms失败,派发库位==》不为空《==，异常信息："+e);
                                    }
                                }

                                // 创新一个入库工作档
                                TaskWrk taskWrk = taskWrkService.selectByTaskNo(getWmsDto.getWrkNo());
                                if(Cools.isEmpty(taskWrk)) {
                                    taskWrk = createTask(getWmsDto,barcode);
                                    if (Cools.isEmpty(taskWrk)){
                                        log.error("库位异常，库位号：{}", getWmsDto.getTargetLocationCode());
                                    }else {
                                        taskWrkService.insert(taskWrk);
                                        StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                                                .eq("crn_no", taskWrk.getCrnNo()).eq("type_no",1).eq("stn_no",staProtocol.getSiteId()));
                                        staProtocol.setWorkNo(taskWrk.getWrkNo());
                                        staProtocol.setStaNo(staDesc.getCrnStn());
                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                    }
                                }

                            }else {
                                continue;
                            }

                        } else {
                            // 退回
                            log.error("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
@@ -379,6 +296,254 @@
        }
    }

    public void generateStoreWrkFileIsEmptyMk() {
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                // 遍历入库口
                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    // 获取入库站信息
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    Integer workNo = staProtocol.getWorkNo();
                    Integer stano = staProtocol.getStaNo();

                    // 尺寸检测异常
                    boolean back = false;
                    String errMsg = "";
                    if (staProtocol.isFrontErr()) {
                        errMsg = "前超限";
                        back = true;
                    }
                    if (!back && staProtocol.isBackErr()) {
                        errMsg = "后超限";
                        back = true;
                    }
                    if (!back && staProtocol.isHighErr()) {
                        errMsg = "高超限";
                        back = true;
                    }
                    if (!back && staProtocol.isLeftErr()) {
                        errMsg = "左超限";
                        back = true;
                    }
                    if (!back && staProtocol.isRightErr()) {
                        errMsg = "右超限";
                        back = true;
                    }
                    if (!back && staProtocol.isWeightErr()) {
                        errMsg = "超重";
                        back = true;
                    }
                    // 退回
                    if (back) {
                        if (stano == inSta.getBackSta().shortValue()) {
                            continue;
                        }
                        if (workNo == 0 && stano == 0) {
                            continue;
                        }
                        if (!staProtocol.isPakMk()) {
                            continue;
                        }
//                        News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
                        staProtocol.setWorkNo(workNo);
                        staProtocol.setStaNo(inSta.getStaNo());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
                        if (taskWrk != null) {
                            taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
                            taskWrk.setModiTime(new Date());
                            taskWrkMapper.updateById(taskWrk);
                        }
                        continue;
                    }
                    // 判断是否满足入库条件
                    if (staProtocol.isAutoing() && staProtocol.isLoading()
                            && staProtocol.isInEnable()
                            && staProtocol.isEmptyMk() && (workNo == 0 || (workNo>9000 && workNo<10000))
                            && staProtocol.isPakMk()
                            && staProtocol.isPakMkWalk()
                    ) {
                        // 请求wms接口，获取工作号和目标库位
                        ToWmsDTO toWmsDTO = new ToWmsDTO("", staProtocol.getSiteId(), 1);

                        HashMap<String, Object> headParam = new HashMap<>();
                        headParam.put("Content-Type", "application/json");
                        String response;
                        try {
                            response = new HttpHandler.Builder()
                                    // .setHeaders(headParam)
                                    .setUri(wmsUrl)
                                    .setPath(inboundTaskApplyPath)
                                    .setJson(JSON.toJSONString(toWmsDTO))
                                    .build()
                                    .doPost();
                        } catch (Exception e) {
                            log.error("请求入库调用接口失败");
                            log.error("异常信息打印：" + e);
                            try {
                                BasDevp basDevp = basDevpService.selectById(inSta.getStaNo());
                                if (Cools.isEmpty(basDevp)) {
                                    log.error("站点号异常" + inSta.getStaNo());
                                } else if (basDevp.getStaErr() != 0) {
                                    basDevp.setStaErr(2);
                                    basDevpService.updateById(basDevp);
                                }
                            } catch (Exception e1) {
                                // 退回
                                log.error("扫码检测程序异常" + inSta.getStaNo() + "异常信息" + e1);
                            }
                            staProtocol.setWorkNo(9999);
                            staProtocol.setStaNo(inSta.getStaNo());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            continue;
                        }

                        JSONObject jsonObject = JSON.parseObject(response);
                        apiLogService.save("wms请求入库货位接口"
                                , wmsUrl + inboundTaskApplyPath
                                , null
                                , "127.0.0.1"
                                , JSON.toJSONString(toWmsDTO)
                                , response
                                , true
                        );
                        log.info("入库请求参数{}" + JSON.toJSONString(toWmsDTO));
                        log.info("入库请求返回参数{}" + JSON.toJSONString(response));
                        if (jsonObject.getInteger("code").equals(200)) {
                            try {
                                devpThread.setPakMk(staProtocol.getSiteId(), false);
                            } catch (Exception e) {
//                                    log.error("扫码检测程序异常"+inSta.getStaNo()+"异常信息"+e);
                                // 退回
                                log.error("扫码检测程序异常" + inSta.getStaNo() + errMsg);
                                log.error("扫码检测程序异常,异常信息" + e);

                                staProtocol.setWorkNo(9999);
                                staProtocol.setStaNo(inSta.getStaNo());
                                devpThread.setPakMk(staProtocol.getSiteId(), false);
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            }
                        } else {
                            continue;
                        }
                    }
                }
            }
        } catch (Exception e) {
            log.error("generateStoreWrkFile e", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }


    public void generateStoreWrkFileWalk() {
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                // 遍历入库口
                for (DevpSlave.Sta inSta : devp.getInWalkSta()) {
                    // 获取入库站信息
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    Integer workNo = staProtocol.getWorkNo();

                    // 判断是否满足入库条件
                    if (staProtocol.isAutoing() && staProtocol.isLoading()
                            && staProtocol.isInEnable() && (workNo == 0 || (workNo>9000 && workNo<10000))
                            && staProtocol.isPakMkWalk()
                    ) {
                        if (inSta.isBarcodeSign()){
                            // 获取条码扫描仪信息
                            BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
                            if (barcodeThread == null) {
                                continue;
                            }
                            String barcode = barcodeThread.getBarcode();
                            if (!Cools.isEmpty(barcode) && !barcode.equals("99999999")) {
                                // 请求wms接口，获取工作号和目标库位
                                ToWmsDTO toWmsDTO = new ToWmsDTO(barcode, staProtocol.getSiteId(), 0);
                                TaskWrk taskWrk1 = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", barcode));

                                if (!Cools.isEmpty(taskWrk1)) {
                                    log.info("托盘码：" + barcode + "任务档存在");
                                    if (taskWrk1.getIoType() == 1 && taskWrk1.getStartPoint().equals(staProtocol.getSiteId().toString())) {
                                        StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                                                .eq("CRN_NO", taskWrk1.getCrnNo()).eq("TYPE_NO", 1).eq("STN_NO", staProtocol.getSiteId()));

                                        if (Cools.isEmpty(staDesc)) {
                                            log.info("托盘码：" + barcode + "任务档存在");
                                            return;
                                        } else {
                                            staProtocol.setWorkNo(taskWrk1.getWrkNo());
                                            staProtocol.setStaNo(staDesc.getCrnStn());
                                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                        }
                                    }
                                    return;
                                }
                            } else {
                                TaskWrk taskWrk1 = taskWrkService.selectOne(new EntityWrapper<TaskWrk>());

                                if (!Cools.isEmpty(taskWrk1)) {
                                    if (taskWrk1.getIoType() == 1 && taskWrk1.getStartPoint().equals(staProtocol.getSiteId().toString())) {
                                        StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                                                .eq("CRN_NO", taskWrk1.getCrnNo()).eq("TYPE_NO", 1).eq("STN_NO", staProtocol.getSiteId()));

                                        if (Cools.isEmpty(staDesc)) {
                                            return;
                                        } else {
                                            staProtocol.setWorkNo(taskWrk1.getWrkNo());
                                            staProtocol.setStaNo(staDesc.getCrnStn());
                                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                        }
                                    }
                                    return;
                                }
                            }
                        } else {
                            TaskWrk taskWrk1 = taskWrkService.selectOne(new EntityWrapper<TaskWrk>());

                            if (!Cools.isEmpty(taskWrk1)) {
                                if (taskWrk1.getIoType() == 1 && taskWrk1.getStartPoint().equals(staProtocol.getSiteId().toString())) {
                                    StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                                            .eq("CRN_NO", taskWrk1.getCrnNo()).eq("TYPE_NO", 1).eq("STN_NO", staProtocol.getSiteId()));

                                    if (Cools.isEmpty(staDesc)) {
                                        return;
                                    } else {
                                        staProtocol.setWorkNo(taskWrk1.getWrkNo());
                                        staProtocol.setStaNo(staDesc.getCrnStn());
                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                    }
                                }
                                return;
                            }
                        }
                    }


                }
            }
        } catch (Exception e) {
            log.error("generateStoreWrkFile e", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

    /**
     * 堆垛机站出库到出库站
     */
@@ -388,15 +553,17 @@
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnSlave.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }
            if (crnProtocol == null) {
                continue;
            }
            BasCrnp basCrnp = basCrnpService.selectById(crnSlave.getId());
            if (basCrnp == null) {
                log.error("{}号堆垛机尚未在数据库进行维护！", crnSlave.getId());
                continue;
            }
            if (!crnSlave.getId().equals(crnProtocol.getLaneNo())){
            if (!crnSlave.getId().equals(crnProtocol.getLaneNo())) {
                for (CrnSlave crnOther : slaveProperties.getCrn()) {
                    if (crnOther.getId().equals(crnProtocol.getLaneNo())){
                    if (crnOther.getId().equals(crnProtocol.getLaneNo())) {
                        crnSlave.updateCrnInStn(crnOther);
                    }
                }
@@ -404,10 +571,9 @@
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {

                List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("CRN_NO", crnSlave.getId()).eq("LANE_NO", crnProtocol.getLaneNo()).eq("CRN_STN", crnStn.getStaNo()));
//                List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnSlave.getId()).eq("").eq("crn_stn", crnStn.getStaNo()));
                for (StaDesc staDesc : staDescs){
                    try{
                List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("CRN_NO", crnProtocol.getLaneNo()).eq("CRN_STN", crnStn.getStaNo()));
                for (StaDesc staDesc : staDescs) {
                    try {
                        // 获取堆垛机出库站信息
                        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                        StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
@@ -422,33 +588,33 @@
                            if (taskWrk == null) {
                                continue;
                            }
                            log.info("下发输送线任务：taskWrk:"+JSON.toJSONString(taskWrk));
                            log.info("下发输送线任务：taskWrk:" + JSON.toJSONString(taskWrk));
//                            R r = siteController.siteDetlUpdate(Integer.valueOf(taskWrk.getTargetPoint()), taskWrk.getWrkNo().shortValue(), (short) 0, "Y", false, false);
                            staProtocol.setWorkNo(taskWrk.getWrkNo());
                            staProtocol.setStaNo(staDesc.getCrnStn());
                            boolean offer = false;
                            try{
                            try {
                                offer = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
                            }catch (Exception e){
                                log.error("下发输送线任务失败：异常:"+e);
                                log.error("下发输送线任务失败：异常:offer:"+offer);
                            } catch (Exception e) {
                                log.error("下发输送线任务失败：异常:" + e);
                                log.error("下发输送线任务失败：异常:offer:" + offer);
                            }
//                            JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(r));
                            if (offer){
                                log.info("下发输送线任务成功：taskWrk:"+JSON.toJSONString(taskWrk));
                            if (offer) {
                                log.info("下发输送线任务成功：taskWrk:" + JSON.toJSONString(taskWrk));
                                Date now = new Date();
                                taskWrk.setStatus(5);
                                taskWrk.setWrkSts(14);
                                taskWrk.setModiTime(now);
                                taskWrk.setCompleteTime(now);
                                taskWrkService.updateById(taskWrk);
                            }else {
                                log.error("下发输送线任务失败：taskWrk:"+JSON.toJSONString(taskWrk));
                            } else {
                                log.error("下发输送线任务失败：taskWrk:" + JSON.toJSONString(taskWrk));
//                                log.error("下发输送线任务失败：异常信息:"+JSON.toJSONString(r));
                            }
                        }
                    }catch (Exception e){
                        log.error("出库到出库站异常:异常信息："+e);
                    } catch (Exception e) {
                        log.error("出库到出库站异常:异常信息：" + e);
                    }
                }

@@ -464,16 +630,18 @@
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }
            if (crnProtocol == null) {
                continue;
            }
            BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
            if (basCrnp == null) {
                log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
                continue;
            }

            if (!crn.getId().equals(crnProtocol.getLaneNo())){
            if (!crn.getId().equals(crnProtocol.getLaneNo())) {
                for (CrnSlave crnOther : slaveProperties.getCrn()) {
                    if (crnOther.getId().equals(crnProtocol.getLaneNo())){
                    if (crnOther.getId().equals(crnProtocol.getLaneNo())) {
                        crn.updateCrnInStn(crnOther);
                    }
                }
@@ -515,7 +683,8 @@
     */
    public void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol) throws IOException {
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("CRN_NO", slave.getId()).eq("LANE_NO", crnProtocol.getLaneNo()).eq("CRN_STN", crnStn.getStaNo()));
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("CRN_NO", crnProtocol.getLaneNo()).eq("CRN_STN", crnStn.getStaNo()));

            for (StaDesc staDesc : staDescs) {
                boolean flag = false;
                // 获取堆垛机入库站信息
@@ -533,7 +702,7 @@
                    continue;
                }
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
                        && staDetl.getCanining()!=null && staDetl.getCanining().equals("Y")) {
                        && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
                    flag = true;
                }
                if (!flag) {
@@ -542,7 +711,7 @@

                // 获取工作状态为2（设备上走）的入库工作档
                TaskWrk taskWrk = taskWrkMapper.selectPakIn(crnProtocol.getLaneNo(), staProtocol.getWorkNo().intValue(), staDesc.getStnNo().toString());
                if(null == taskWrk) {
                if (null == taskWrk) {
                    continue;
                }

@@ -601,7 +770,7 @@
                // 命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                crnCommand.setCrnNo(staDesc.getLaneNo()); // 堆垛机巷道编号
                crnCommand.setCrnNo(crnProtocol.getLaneNo()); // 堆垛机巷道编号
                crnCommand.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
@@ -611,23 +780,23 @@
                crnCommand.setDestinationPosX(Utils.getRowShort(taskWrk.getTargetPoint()));     // 目标库位列
                crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint()));     // 目标库位层
                crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint()));     // 目标库位排
                crnCommand.setCommand((short)1);
                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand),false)) {
                crnCommand.setCommand((short) 1);
                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand), false)) {
                    log.error("堆垛机命令生成失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                    throw new CoolException("堆垛机命令生成失败");
                }else{
                    try{
                } else {
                    try {
                        taskWrkService.updateById(taskWrk);
                    }catch (Exception e){
                    } catch (Exception e) {
                        log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", taskWrk.getWrkNo());
                        log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，异常："+e);
                        log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，异常：" + e);
                    }
                    try{
                    try {
                        HashMap<String, Object> headParam = new HashMap<>();
                        headParam.put("taskNo",taskWrk.getTaskNo());
                        headParam.put("status",taskWrk.getStatus());
                        headParam.put("ioType",taskWrk.getIoType());
                        headParam.put("barcode",taskWrk.getBarcode());
                        headParam.put("taskNo", taskWrk.getTaskNo());
                        headParam.put("status", taskWrk.getStatus());
                        headParam.put("ioType", taskWrk.getIoType());
                        headParam.put("barcode", taskWrk.getBarcode());
                        String response;
                        response = new HttpHandler.Builder()
                                // .setHeaders(headParam)
@@ -638,14 +807,14 @@
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        apiLogService.save("wcs派发入库任务上报wms"
                                ,wmsUrl+taskStatusFeedbackPath
                                ,null
                                ,"127.0.0.1"
                                ,JSON.toJSONString(headParam)
                                ,response
                                ,true
                                , wmsUrl + taskStatusFeedbackPath
                                , null
                                , "127.0.0.1"
                                , JSON.toJSONString(headParam)
                                , response
                                , true
                        );
                    } catch (Exception e){
                    } catch (Exception e) {
                        log.error("wcs派发入库任务上报wms失败", JSON.toJSONString(taskWrk));
//                        throw new CoolException("wcs派发入库任务上报wms失败");
                    }
@@ -661,19 +830,17 @@
     * 出库  ===>>  库位到堆垛机站
     * 2022-06-09 TQS修改，查询工作档LIST，遍历下发，防止第一个任务堵塞出库
     */
    public void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
    public void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol) {
        List<TaskWrk> taskWrksInitial = taskWrkMapper.selectPakOut(crnProtocol.getLaneNo(), null);
        if (taskWrksInitial.size()==0){
        if (taskWrksInitial.size() == 0) {
            return;
        }
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("CRN_NO", slave.getId()).eq("LANE_NO", crnProtocol.getLaneNo()).eq("CRN_STN", crnStn.getStaNo()));

//            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnProtocol.getLaneNo()).eq("crn_stn", crnStn.getStaNo()));
            for (StaDesc staDesc : staDescs){
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("CRN_NO", crnProtocol.getLaneNo()).eq("CRN_STN", crnStn.getStaNo()));
            for (StaDesc staDesc : staDescs) {
                // 获取工作状态为11（生成出库ID）的出库工作档
                List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(crnProtocol.getLaneNo(),staDesc.getStnNo().toString());
                for (TaskWrk taskWrk : taskWrks){
                List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(crnProtocol.getLaneNo(), staDesc.getStnNo().toString());
                for (TaskWrk taskWrk : taskWrks) {
                    if (taskWrk == null) {
                        continue;
                    }
@@ -699,7 +866,7 @@
                    }

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

@@ -725,12 +892,12 @@
                        command.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                        command.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                        command.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                        command.setCommand((short)1);
                        if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, command),false)) {
                            log.error("堆垛机命令生成失败，堆垛机号={}，巷道={}，任务数据={}",slave.getId(), taskWrk.getCrnNo(), JSON.toJSON(command));
                        command.setCommand((short) 1);
                        if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, command), false)) {
                            log.error("堆垛机命令生成失败，堆垛机号={}，巷道={}，任务数据={}", slave.getId(), taskWrk.getCrnNo(), JSON.toJSON(command));
                            throw new CoolException("堆垛机命令生成失败");
                        }else{
                            try{
                        } else {
                            try {
                                // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                                Date now = new Date();
                                taskWrk.setWrkSts(12);
@@ -740,16 +907,16 @@
                                if (taskWrkMapper.updateById(taskWrk) == 0) {
                                    log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                                }
                            }catch (Exception e){
                            } catch (Exception e) {
                                log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                                log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，异常："+e);
                                log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，异常：" + e);
                            }
                            try{
                            try {
                                HashMap<String, Object> headParam = new HashMap<>();
                                headParam.put("taskNo",taskWrk.getTaskNo());
                                headParam.put("status",taskWrk.getStatus());
                                headParam.put("ioType",taskWrk.getIoType());
                                headParam.put("barcode",taskWrk.getBarcode());
                                headParam.put("taskNo", taskWrk.getTaskNo());
                                headParam.put("status", taskWrk.getStatus());
                                headParam.put("ioType", taskWrk.getIoType());
                                headParam.put("barcode", taskWrk.getBarcode());
                                String response;
                                response = new HttpHandler.Builder()
                                        // .setHeaders(headParam)
@@ -760,14 +927,14 @@
                                        .doPost();
                                JSONObject jsonObject = JSON.parseObject(response);
                                apiLogService.save("wcs派发出库任务上报wms"
                                        ,wmsUrl+taskStatusFeedbackPath
                                        ,null
                                        ,"127.0.0.1"
                                        ,JSON.toJSONString(headParam)
                                        ,response
                                        ,true
                                        , wmsUrl + taskStatusFeedbackPath
                                        , null
                                        , "127.0.0.1"
                                        , JSON.toJSONString(headParam)
                                        , response
                                        , true
                                );
                            }catch (Exception e){
                            } catch (Exception e) {
                                log.error("wcs派发出库任务上报wms失败", JSON.toJSONString(taskWrk));
//                                throw new CoolException("wcs派发入库任务上报wms失败");
                            }
@@ -781,16 +948,16 @@
    /**
     * 库位移转
     */
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol) {
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的移库工作档
            List<TaskWrk> taskWrks = taskWrkMapper.selectList(
                    new EntityWrapper<TaskWrk>()
                    .eq("CRN_NO",crnProtocol.getLaneNo())
                    .eq("WRK_STS",11)
                    .eq("IO_TYPE",3)
                    .orderBy("IO_PRI",false));
            for (TaskWrk taskWrk : taskWrks){
                            .eq("CRN_NO", crnProtocol.getLaneNo())
                            .eq("WRK_STS", 11)
                            .eq("IO_TYPE", 3)
                            .orderBy("IO_PRI", false));
            for (TaskWrk taskWrk : taskWrks) {

                // 双深库位且浅库位有货，则需先对浅库位进行库位移转
//                if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
@@ -822,8 +989,6 @@
                // 命令下发区 --------------------------------------------------------------------------




                // 1.堆垛机开始移动
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
@@ -838,7 +1003,7 @@
                crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint()));     // 目标库位列
                crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint()));     // 目标库位层
                crnCommand.setCommand((short) 1);
                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand),false)) {
                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand), false)) {
                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改工作档状态 11.生成出库ID => 12.吊车出库中
@@ -850,12 +1015,12 @@
                    if (taskWrkMapper.updateById(taskWrk) == 0) {
                        log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                    }
                    try{
                    try {
                        HashMap<String, Object> headParam = new HashMap<>();
                        headParam.put("taskNo",taskWrk.getTaskNo());
                        headParam.put("status",taskWrk.getStatus());
                        headParam.put("ioType",taskWrk.getIoType());
                        headParam.put("barcode",taskWrk.getBarcode());
                        headParam.put("taskNo", taskWrk.getTaskNo());
                        headParam.put("status", taskWrk.getStatus());
                        headParam.put("ioType", taskWrk.getIoType());
                        headParam.put("barcode", taskWrk.getBarcode());
                        String response;
                        response = new HttpHandler.Builder()
                                // .setHeaders(headParam)
@@ -866,14 +1031,14 @@
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        apiLogService.save("wcs派发移库任务上报wms"
                                ,wmsUrl+taskStatusFeedbackPath
                                ,null
                                ,"127.0.0.1"
                                ,JSON.toJSONString(headParam)
                                ,response
                                ,true
                                , wmsUrl + taskStatusFeedbackPath
                                , null
                                , "127.0.0.1"
                                , JSON.toJSONString(headParam)
                                , response
                                , true
                        );
                    }catch (Exception e){
                    } catch (Exception e) {
                        log.error("wcs派发移库库任务上报wms失败", taskWrk);
//                        throw new CoolException("wcs派发移库库任务上报wms失败");
                    }
@@ -893,11 +1058,13 @@
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }
            if (crnProtocol == null) {
                continue;
            }

            if (!crn.getId().equals(crnProtocol.getLaneNo())){
            if (!crn.getId().equals(crnProtocol.getLaneNo())) {
                for (CrnSlave crnOther : slaveProperties.getCrn()) {
                    if (crnOther.getId().equals(crnProtocol.getLaneNo())){
                    if (crnOther.getId().equals(crnProtocol.getLaneNo())) {
                        crn.updateCrnInStn(crnOther);
                    }
                }
@@ -906,20 +1073,20 @@
            //  状态：等待确认 并且  任务完成位 = 1
            if (!Cools.isEmpty(crnProtocol.getTaskFinish()) && crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
                //获取入库待确认工作档
                TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crnProtocol.getLaneNo(),crnProtocol.getTaskNo().intValue());
                if (Cools.isEmpty(taskWrk)&&crnProtocol.getTaskNo() !=999) {
                    log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，巷道号={}，工作号={}", crn.getId(),crnProtocol.getLaneNo(), crnProtocol.getTaskNo());
                TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crnProtocol.getLaneNo(), crnProtocol.getTaskNo().intValue());
                if (Cools.isEmpty(taskWrk) && crnProtocol.getTaskNo() != 999) {
                    log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，巷道号={}，工作号={}", crn.getId(), crnProtocol.getLaneNo(), crnProtocol.getTaskNo());
                    continue;
                }
                Thread.sleep(300);
                //确认完成信号
                CrnOperatorParam crnOperatorParam=new CrnOperatorParam();
                CrnOperatorParam crnOperatorParam = new CrnOperatorParam();
                crnOperatorParam.setCrnNo(crn.getId());
                Date now = new Date();

                crnController.crnTaskComplete(crnOperatorParam);
                if(!Cools.isEmpty(taskWrk)){
                    if(taskWrk.getIoType()==1 && taskWrk.getWrkSts()==3){
                if (!Cools.isEmpty(taskWrk)) {
                    if (taskWrk.getIoType() == 1 && taskWrk.getWrkSts() == 3) {
                        taskWrk.setWrkSts(4);//入库完成
                        taskWrk.setStatus(5);//完结
                        //更新库位状态
@@ -929,7 +1096,7 @@
                        locMast.setModiTime(now);
                        locMast.setModiUser(9999L);
                        locMastService.updateById(locMast);
                    }else if(taskWrk.getIoType()==2&&taskWrk.getWrkSts()==12){
                    } else if (taskWrk.getIoType() == 2 && taskWrk.getWrkSts() == 12) {
                        taskWrk.setWrkSts(13);//出库完成
                        taskWrk.setStatus(5);//完结
                        //更新库位状态
@@ -939,7 +1106,7 @@
                        locMast.setModiTime(now);
                        locMast.setModiUser(9999L);
                        locMastService.updateById(locMast);
                    }else if(taskWrk.getIoType()==3&&taskWrk.getWrkSts()==12){
                    } else if (taskWrk.getIoType() == 3 && taskWrk.getWrkSts() == 12) {
                        taskWrk.setWrkSts(4);//入库完成
                        taskWrk.setStatus(5);//完结
                        //更新库位状态
@@ -962,12 +1129,12 @@
                    taskWrkService.updateById(taskWrk);


                    try{
                    try {
                        HashMap<String, Object> headParam = new HashMap<>();
                        headParam.put("taskNo",taskWrk.getTaskNo());
                        headParam.put("status",taskWrk.getStatus());
                        headParam.put("ioType",taskWrk.getIoType());
                        headParam.put("barcode",taskWrk.getBarcode());
                        headParam.put("taskNo", taskWrk.getTaskNo());
                        headParam.put("status", taskWrk.getStatus());
                        headParam.put("ioType", taskWrk.getIoType());
                        headParam.put("barcode", taskWrk.getBarcode());
                        String response;
                        log.error("wcs完结任务上报wms==》", headParam);

@@ -984,14 +1151,14 @@
//                        log.error("wcs完结任务上报wms==》", jsonObject);

                        apiLogService.save("wcs派发入库任务上报wms"
                                ,wmsUrl+taskStatusFeedbackPath
                                ,null
                                ,"127.0.0.1"
                                ,JSON.toJSONString(headParam)
                                ,response
                                ,true
                                , wmsUrl + taskStatusFeedbackPath
                                , null
                                , "127.0.0.1"
                                , JSON.toJSONString(headParam)
                                , response
                                , true
                        );
                    }catch (Exception e){
                    } catch (Exception e) {
                        log.error("wcs完结任务上报wms失败", taskWrk);
                        log.error("wcs完结任务上报wms失败,报错信息：", e);
//                        throw new CoolException("wcs派发入库任务上报wms失败");
@@ -1005,7 +1172,7 @@
    /**
     * 堆垛机异常信息记录
     */
    public void recCrnErr(){
    public void recCrnErr() {
        Date now = new Date();
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
@@ -1027,7 +1194,7 @@
                                continue;
                            }
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
                            String errName = crnError==null? String.valueOf(crnProtocol.getAlarm()):crnError.getErrName();
                            String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName();
                            BasErrLog basErrLog = new BasErrLog(
                                    null,    // 编号
                                    wrkMast.getWrkNo(),    // 工作号
@@ -1074,7 +1241,7 @@
                        // 记录新异常
                        if (latest == null || (latest.getErrCode() != crnProtocol.getAlarm().intValue())) {
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
                            String errName = crnError==null? String.valueOf(crnProtocol.getAlarm()):crnError.getErrName();
                            String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName();
                            BasErrLog basErrLog = new BasErrLog(
                                    null,    // 编号
                                    null,    // 工作号
@@ -1089,7 +1256,7 @@
                                    null,    // 源站
                                    null,    // 源库位
                                    null,    // 条码
                                    (int)crnProtocol.getAlarm(),    // 异常码
                                    (int) crnProtocol.getAlarm(),    // 异常码
                                    errName,    // 异常
                                    1,    // 异常情况
                                    now,    // 添加时间
@@ -1120,9 +1287,9 @@
        }
    }

    private TaskWrk createTask(GetWmsDto dto, String barcode){
    private TaskWrk createTask(GetWmsDto dto, String barcode) {
        String wcsLocNo = dto.getLocNo();
        if(Cools.isEmpty(wcsLocNo)){
        if (Cools.isEmpty(wcsLocNo)) {
            return null;
        }
        Date now = new Date();
@@ -1142,7 +1309,7 @@
        taskWrk.setCrnNo(locMast.getCrnNo());
        taskWrk.setTargetPoint(wcsLocNo);
        taskWrk.setStartPoint(dto.getStaNo().toString());
        if(taskWrk.getIoType() == 1){
        if (taskWrk.getIoType() == 1) {
            taskWrk.setWrkSts(2);
            if (!Cools.isEmpty(taskWrk.getTargetPoint())) {
                taskWrk.setOriginTargetPoint(taskWrk.getTargetPoint());
@@ -1151,14 +1318,14 @@
        return taskWrk;
    }

    public String rgvOtherTaskWrk(RgvSlave slave){
    public String rgvOtherTaskWrk(RgvSlave slave) {

        RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, slave.getOtherId());
        TaskProtocolCache taskProtocolCache = rgvThread.getTaskProtocolCache();
        ConcurrentHashMap<String, TaskProtocol> allTaskProtocol = taskProtocolCache.getAllTaskProtocol();
        if (!allTaskProtocol.isEmpty()){
            for (TaskProtocol taskProtocol : allTaskProtocol.values()){
                if (taskProtocol.getTaskNo() != 0 ){
        if (!allTaskProtocol.isEmpty()) {
            for (TaskProtocol taskProtocol : allTaskProtocol.values()) {
                if (taskProtocol.getTaskNo() != 0) {
                    return taskProtocol.getTaskNo().toString();
                }
            }
@@ -1166,11 +1333,12 @@
        return "无";

    }
    public boolean rgvDetection(RgvSlave slave){

    public boolean rgvDetection(RgvSlave slave) {
        RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(slave.getId());
        RgvTaskProtocol rgvTaskProtocol = RgvTaskCache.getRgvStatus(slave.getId());

        if (rgvProtocol == null || rgvTaskProtocol ==null) {
        if (rgvProtocol == null || rgvTaskProtocol == null) {
            return false;
        }
        if (!rgvProtocol.getModeType().equals(RgvModeType.AUTO) || rgvProtocol.getRgvPos().equals(0L) || rgvTaskProtocol.getAvoid() == -1 || rgvProtocol.getRgvPosDestination() == 0L
@@ -1183,39 +1351,39 @@
        if (rgvProtocolOther == null) {
            return false;
        }
        if (rgvProtocolOther.statusEnable){
            if (!rgvProtocolOther.getModeType().equals(RgvModeType.AUTO) || rgvProtocolOther.getRgvPos().equals(0L) || rgvTaskProtocolOther.getAvoid() == -1  || rgvProtocolOther.getRgvPosDestination() == 0L) {
        if (rgvProtocolOther.statusEnable) {
            if (!rgvProtocolOther.getModeType().equals(RgvModeType.AUTO) || rgvProtocolOther.getRgvPos().equals(0L) || rgvTaskProtocolOther.getAvoid() == -1 || rgvProtocolOther.getRgvPosDestination() == 0L) {
                return false;
            }
        }
        return true;
    }

    public TaskWrk deviceDetection(RgvSlave.RgvStn inSta){
    public TaskWrk deviceDetection(RgvSlave.RgvStn inSta) {

        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, inSta.getDevpPlcId());
        StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
        if (staProtocol == null){
        if (staProtocol == null) {
            return null;
        }
        // 判断是否满足取货条件
        if (staProtocol.isAutoing()
//                && staProtocol.isLoading()
                && staProtocol.getWorkNo()!=0) {
                && staProtocol.getWorkNo() != 0) {
            TaskWrk taskWrk = taskWrkService.selectByTaskNo(staProtocol.getWorkNo().toString());
            if (taskWrk!=null){
            if (taskWrk != null) {
                return taskWrk;
            }
        }
        return null;
    }

    public boolean rgvOtherStatusEnable(RgvSlave slave){
    public boolean rgvOtherStatusEnable(RgvSlave slave) {
        RgvProtocol rgvProtocolOther = RgvStatusCache.getRgvStatus(slave.getOtherId());
        if (rgvProtocolOther == null) {
            return true;
        }
        if (rgvProtocolOther.statusEnable){
        if (rgvProtocolOther.statusEnable) {
//            if (!rgvProtocolOther.getModeType().equals(RgvModeType.AUTO) || rgvProtocolOther.getRgvPos().equals(0L)) {
            return true;
//            }
@@ -1225,8 +1393,8 @@

    public synchronized void taskStart() {
        for (RgvSlave rgvSlave : slaveProperties.getRgv()) {
            try{
                if (rgvDetection(rgvSlave)){
            try {
                if (rgvDetection(rgvSlave)) {
                    String taskNoNow = rgvOtherTaskWrk(rgvSlave);
                    List<BasDevpPosition> basDevpPositions = basDevpPositionService.selectList(new EntityWrapper<BasDevpPosition>().orderBy("PLC_POSITION", true));
                    boolean itSmall = new TrackRangeUtils().IsItSmall(rgvSlave);
@@ -1236,9 +1404,9 @@
                    }
                    List<TaskWrk> taskWrkList = new ArrayList<>();
                    List<Integer> staList = new ArrayList<>();
                    for (RgvSlave.RgvStn inSta : rgvSlave.getRgvInSta()){
                    for (RgvSlave.RgvStn inSta : rgvSlave.getRgvInSta()) {
                        TaskWrk taskWrk = deviceDetection(inSta);
                        if (taskWrk!=null){
                        if (taskWrk != null) {
                            if (taskWrk.getTaskNo().equals(taskNoNow)) continue;
                            taskWrkList.add(taskWrk);
                            staList.add(inSta.getStaNo());
@@ -1249,9 +1417,9 @@

                    boolean sign = false;

                    if (rgvOtherStatusEnable(rgvSlave)){
                    if (rgvOtherStatusEnable(rgvSlave)) {
                        //分成上下两部分任务
                        List<Integer>[] avoidRange = RouteUtils.gradeRange(staList, basDevpPositions,itSmall);
                        List<Integer>[] avoidRange = RouteUtils.gradeRange(staList, basDevpPositions, itSmall);
                        List<Integer> rangeListSou = avoidRange[itSmall ? 0 : 1];
                        List<Integer> rangeListSouOther = avoidRange[itSmall ? 1 : 0];
                        //就近排序
@@ -1267,87 +1435,87 @@
                        Long[][] avoidedRange = new TrackRangeUtils().avoidRangeArr(rgvSlave, trackEntireLength, trackBenchmark, avoidDistance);
                        List<Integer> belongToRange = RouteUtils.SortNearby(RouteUtils.belongToRange(rangeList, avoidedRange[0], basDevpPositions), rgvProtocol.RgvPos, basDevpPositions);

                        for (Integer staNoNow : belongToRange){
                            for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                if (rgvStn.getStaNo().equals(staNoNow)){
                        for (Integer staNoNow : belongToRange) {
                            for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) {
                                if (rgvStn.getStaNo().equals(staNoNow)) {
                                    TaskWrk taskWrk = deviceDetection(rgvStn);
                                    if (taskWrk!=null){
                                    if (taskWrk != null) {
                                        BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper<BasDevpPosition>().eq("DEV_NO", taskWrk.getTargetPointConvert()));
                                        if (RouteUtils.CheckIfItIsWithinTheRange(rangeList,basDevpPosition.getPlcPosition(),basDevpPositions,itSmall)){
                                            sign = taskGenerate(rgvSlave,rgvStn,0);
                                        if (RouteUtils.CheckIfItIsWithinTheRange(rangeList, basDevpPosition.getPlcPosition(), basDevpPositions, itSmall)) {
                                            sign = taskGenerate(rgvSlave, rgvStn, 0);
                                        }
                                    }
                                    break;
                                }
                            }
                            if (sign){
                            if (sign) {
                                break;
                            }
                        }
                        if (!sign){
                        if (!sign) {
                            //  筛选范围内取货任务
                            for (Integer staNoNow : belongToRange){
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                    if (rgvStn.getStaNo().equals(staNoNow)){
                                        sign = taskGenerate(rgvSlave,rgvStn,0);
                            for (Integer staNoNow : belongToRange) {
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) {
                                    if (rgvStn.getStaNo().equals(staNoNow)) {
                                        sign = taskGenerate(rgvSlave, rgvStn, 0);
                                        break;
                                    }
                                }
                                if (sign){
                                if (sign) {
                                    break;
                                }
                            }
                        }

                        if (!sign){
                            for (Integer staNoNow : rangeList){
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                    if (rgvStn.getStaNo().equals(staNoNow)){
                        if (!sign) {
                            for (Integer staNoNow : rangeList) {
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) {
                                    if (rgvStn.getStaNo().equals(staNoNow)) {
                                        TaskWrk taskWrk = deviceDetection(rgvStn);
                                        if (taskWrk!=null){
                                        if (taskWrk != null) {
                                            BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper<BasDevpPosition>().eq("DEV_NO", taskWrk.getTargetPointConvert()));
                                            if (RouteUtils.CheckIfItIsWithinTheRange(rangeList,basDevpPosition.getPlcPosition(),basDevpPositions,itSmall)){
                                                sign = taskGenerate(rgvSlave,rgvStn,0);
                                            if (RouteUtils.CheckIfItIsWithinTheRange(rangeList, basDevpPosition.getPlcPosition(), basDevpPositions, itSmall)) {
                                                sign = taskGenerate(rgvSlave, rgvStn, 0);
                                            }
                                        }
                                        break;
                                    }
                                }
                                if (sign){
                                if (sign) {
                                    break;
                                }
                            }
                        }
                        if (!sign){
                        if (!sign) {
                            //  半边区域内取货任务
                            for (Integer staNoNow : rangeList){
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                    if (rgvStn.getStaNo().equals(staNoNow)){
                                        sign = taskGenerate(rgvSlave,rgvStn,0);
                            for (Integer staNoNow : rangeList) {
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) {
                                    if (rgvStn.getStaNo().equals(staNoNow)) {
                                        sign = taskGenerate(rgvSlave, rgvStn, 0);
                                        break;
                                    }
                                }
                                if (sign){
                                if (sign) {
                                    break;
                                }
                            }
                        }
                        if (!sign){
                        if (!sign) {
                            //  半边区域内放货任务
                            for (Integer staNoNow : rangeListOther){
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                    if (rgvStn.getStaNo().equals(staNoNow)){
                            for (Integer staNoNow : rangeListOther) {
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) {
                                    if (rgvStn.getStaNo().equals(staNoNow)) {
                                        TaskWrk taskWrk = deviceDetection(rgvStn);
                                        if (taskWrk!=null){
                                        if (taskWrk != null) {
                                            BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper<BasDevpPosition>().eq("DEV_NO", taskWrk.getTargetPointConvert()));
                                            if (RouteUtils.CheckIfItIsWithinTheRange(rangeList,basDevpPosition.getPlcPosition(),basDevpPositions,itSmall)){
                                                sign = taskGenerate(rgvSlave,rgvStn,0);
                                            if (RouteUtils.CheckIfItIsWithinTheRange(rangeList, basDevpPosition.getPlcPosition(), basDevpPositions, itSmall)) {
                                                sign = taskGenerate(rgvSlave, rgvStn, 0);
                                            }
                                        }
                                        break;
                                    }
                                }
                                if (sign){
                                if (sign) {
                                    break;
                                }
                            }
@@ -1358,33 +1526,34 @@
                        RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(rgvSlave.getId());
                        List<Integer> rangeList = RouteUtils.SortNearby(staList, rgvProtocol.RgvPos, basDevpPositions);
                        //  半边区域内取货任务
                        for (Integer staNoNow : rangeList){
                            for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                if (rgvStn.getStaNo().equals(staNoNow)){
                                    sign = taskGenerate(rgvSlave,rgvStn,0);
                        for (Integer staNoNow : rangeList) {
                            for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) {
                                if (rgvStn.getStaNo().equals(staNoNow)) {
                                    sign = taskGenerate(rgvSlave, rgvStn, 0);
                                    break;
                                }
                            }
                            if (sign){
                            if (sign) {
                                break;
                            }
                        }
                    }
                }
            } catch (Exception e){
                log.error("任务生成失败===》异常信息：{}",e.getMessage());
            } catch (Exception e) {
                log.error("任务生成失败===》异常信息：{}", e.getMessage());
            }
        }
    }

    //获取起点与终点对象
    public RgvSlave.RgvStn getRgvStnNow(RgvSlave rgvSlave,Integer staNo) {
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
            if (rgvStn.getStaNo().equals(staNo)){
    public RgvSlave.RgvStn getRgvStnNow(RgvSlave rgvSlave, Integer staNo) {
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) {
            if (rgvStn.getStaNo().equals(staNo)) {
                return rgvStn;
            }
        }
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvOutSta()){
            if (rgvStn.getStaNo().equals(staNo)){
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvOutSta()) {
            if (rgvStn.getStaNo().equals(staNo)) {
                return rgvStn;
            }
        }
@@ -1392,43 +1561,43 @@
    }

    //获取起点与终点对象
    public RgvSlave.RgvStn[] getRgvStnAll(RgvSlave rgvSlave,Integer souSta,Integer endSta) {
    public RgvSlave.RgvStn[] getRgvStnAll(RgvSlave rgvSlave, Integer souSta, Integer endSta) {
        RgvSlave.RgvStn[] rgvStns = new RgvSlave.RgvStn[2];
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
            if (rgvStn.getStaNo().equals(souSta)){
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()) {
            if (rgvStn.getStaNo().equals(souSta)) {
                rgvStns[0] = rgvStn;
            }
        }
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvOutSta()){
            if (rgvStn.getStaNo().equals(endSta)){
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvOutSta()) {
            if (rgvStn.getStaNo().equals(endSta)) {
                rgvStns[1] = rgvStn;
            }
        }
        return rgvStns;
    }

    public boolean taskGenerate(RgvSlave rgvSlave,RgvSlave.RgvStn rgvStn,Integer sign) {
        try{
    public boolean taskGenerate(RgvSlave rgvSlave, RgvSlave.RgvStn rgvStn, Integer sign) {
        try {
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
            TaskProtocolCache taskProtocolCache = rgvThread.getTaskProtocolCache();

            TaskProtocol issuedTake = new TaskProtocol();
            TaskProtocol issuedPut = new TaskProtocol();
            try{
            try {
                ConcurrentHashMap<String, TaskProtocol> allTaskProtocol = taskProtocolCache.getAllTaskProtocol();
                if (allTaskProtocol.size() > 0){
                if (allTaskProtocol.size() > 0) {
                    return false;
                }
                TaskWrk taskWrk = deviceDetection(rgvStn);
                if (taskWrk == null){
                if (taskWrk == null) {
                    return false;
                }
                Integer targetPointConvert = taskWrk.getTargetPointConvert();
                if (targetPointConvert == null){
                if (targetPointConvert == null) {
                    return false;
                }
                RgvSlave.RgvStn rgvStnEnd = getRgvStnNow(rgvSlave, targetPointConvert);
                if (rgvStnEnd == null){
                if (rgvStnEnd == null) {
                    return false;
                }

@@ -1437,7 +1606,7 @@
                //执行
                issuedTake.setTaskNo(Long.valueOf(taskWrk.getTaskNo()));
                issuedTake.setTaskStatus(1);
                issuedTake.setTaskNoDirection(issuedTake.gettaskNoDirection$(issuedTake.getTaskNo(),issuedTake.getTaskStatus()));
                issuedTake.setTaskNoDirection(issuedTake.gettaskNoDirection$(issuedTake.getTaskNo(), issuedTake.getTaskStatus()));
                issuedTake.setTargetPosition(basDevpPositionSou.getPlcPosition());
                issuedTake.setIsRunning(1);
                issuedTake.setDirection(rgvStn.isDirection());
@@ -1445,16 +1614,16 @@

                issuedPut.setTaskNo(Long.valueOf(taskWrk.getTaskNo()));
                issuedPut.setTaskStatus(2);
                issuedPut.setTaskNoDirection(issuedPut.gettaskNoDirection$(issuedPut.getTaskNo(),issuedPut.getTaskStatus()));
                issuedPut.setTaskNoDirection(issuedPut.gettaskNoDirection$(issuedPut.getTaskNo(), issuedPut.getTaskStatus()));
                issuedPut.setTargetPosition(basDevpPositionEnd.getPlcPosition());
                issuedPut.setIsRunning(1);
                issuedPut.setDirection(rgvStnEnd.isDirection());
            }catch (Exception e){
                log.error("任务生成失败issued1===》异常信息：{}",e.getMessage());
            } catch (Exception e) {
                log.error("任务生成失败issued1===》异常信息：{}", e.getMessage());
                return false;
            }

            switch (sign){
            switch (sign) {
                case 1:
                    taskProtocolCache.updateTaskProtocol(issuedTake);
                    break;
@@ -1466,12 +1635,11 @@
                    taskProtocolCache.updateTaskProtocol(issuedPut);
                    break;
            }
        } catch (Exception e){
            log.error("任务生成失败issued2===》异常信息：{}",e.getMessage());
        } catch (Exception e) {
            log.error("任务生成失败issued2===》异常信息：{}", e.getMessage());
        }
        return true;
    }



}