*

lsh

2025-04-08 ddc9842f99172338bd7606de3c9a8cf520d7a0b4

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

@@ -4,6 +4,7 @@
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.R;
import com.core.exception.CoolException;
import com.zy.asrs.controller.CrnController;
import com.zy.asrs.controller.OpenController;
@@ -169,12 +170,13 @@
                        }
//                        News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
                        staProtocol.setWorkNo(workNo);
                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
                        staProtocol.setStaNo(inSta.getStaNo().shortValue());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
                        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;
@@ -182,7 +184,7 @@
                    // 判断是否满足入库条件
                    if (staProtocol.isAutoing() && staProtocol.isLoading()
                            && staProtocol.isInEnable()
                            && !staProtocol.isEmptyMk() && (workNo >= 0)
                            && !staProtocol.isEmptyMk() && (workNo == 9991 )
                            && staProtocol.isPakMk()) {
                        // 获取条码扫描仪信息
                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
@@ -196,18 +198,57 @@
                            TaskWrk taskWrk1=taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode",barcode));
                            if(!Cools.isEmpty(taskWrk1)){
                                log.info("托盘码："+barcode+"任务档存在");
                                continue;
                                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().shortValue());
                                        staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                    }
                                }
                                return;
                            }
                            HashMap<String, Object> headParam = new HashMap<>();
                            headParam.put("Content-Type","application/json");
                            String response;
                            response = new HttpHandler.Builder()
                                   // .setHeaders(headParam)
                                    .setUri(wmsUrl)
                                    .setPath(inboundTaskApplyPath)
                                    .setJson(JSON.toJSONString(toWmsDTO))
                                    .build()
                                    .doPost();
                            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((short)9999);
                                staProtocol.setStaNo(inSta.getStaNo().shortValue());
                                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请求入库货位接口"
@@ -219,9 +260,49 @@
                                    ,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);
                                    // 退回
                                    log.error("扫码检测程序异常"+inSta.getStaNo()+errMsg);
                                    log.error("扫码检测程序异常,异常信息"+e);

                                    staProtocol.setWorkNo((short)9999);
                                    staProtocol.setStaNo(inSta.getStaNo().shortValue());
                                    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")
@@ -242,7 +323,7 @@
                                                .build()
                                                .doPost();
                                        JSONObject jsonObject1 = JSON.parseObject(response2);
                                        apiLogService.save("wcs派发库位不为空上报wms"
                                        apiLogService.save("wcs派发库位==》不为空《==上报wms"
                                                ,wmsUrl+taskStatusFeedbackPath
                                                ,null
                                                ,"127.0.0.1"
@@ -251,8 +332,8 @@
                                                ,true
                                        );
                                    }catch (Exception e){
                                        log.error("wcs派发库位不为空上报wms", getWmsDto.getWrkNo());
                                        throw new CoolException("wcs派发入库任务上报wms失败");
                                        log.error("wcs派发库位==》不为空《==上报wms", getWmsDto.getWrkNo());
                                        throw new CoolException("wcs派发入库任务上报wms失败,派发库位==》不为空《==，异常信息："+e);
                                    }
                                }

@@ -276,79 +357,20 @@
                                continue;
                            }

//                        StaDescService staDescService = SpringUtils.getBean(StaDescService.class);
//
//                        ToWmsDTO toWmsDTO = new ToWmsDTO();
//                        Map<String, Object> map = new HashMap<>();
//                        map.put("x-api-key","7a15b5db-29b6-552c-8cff-0cfec3756da2");
//                        List<Integer> list = openServiceImpl.getInEnableRoadway();
//                        TaskWrk taskWrk = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", barcode));
//
//                        if (Cools.isEmpty(taskWrk)){
//                            continue;
//                        }
//                        //StaDesc staDesc1 = staDescService.selectOne(new EntityWrapper<StaDesc>().eq("stn_no",inSta.getBackSta()));
//                        if (taskWrk.getTargetPoint() != null && taskWrk.getStartPoint() != null){
//                            if ( taskWrk.getWrkNo() != null && taskWrk.getWrkNo().shortValue() == workNo ){
//                                continue;
//                            }
//                            //获取堆垛机站点
//                            StaDesc staDesc = new StaDesc();
//                            if (devp.getId() <= 1){
//                                staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
//                                        .eq("crn_no", taskWrk.getCrnNo()).eq("type_no",1).lt("stn_no", 200));
//                            }else {
//                                staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
//                                        .eq("crn_no", taskWrk.getCrnNo()).eq("type_no",1).lt("stn_no", 400).ge("stn_no", 250));
//                            }
//                            staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
//                            staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
//                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
//                            Thread.sleep(500);
//                        }else {
//                            //TaskWrk taskWrk = taskWrkService.selectByTaskNo(param.getTaskNo());
//                            toWmsDTO.setWarehouseId("1688469798893297665");
//                            toWmsDTO.setContainerCode(barcode);
//                            toWmsDTO.setApplyType("TUNNEL_LOCATION");
//                            toWmsDTO.setTaskTunnel(taskWrk.getCrnNo());
//                            toWmsDTO.setCanInboundTunnels(list);
//                            String response = null;
//                            try {
//                                response = new HttpHandler.Builder()
//                                        .setHeaders(map)
//                                        .setUri(wmsUrl)
//                                        .setPath(inboundTaskApplyPath)
//                                        .setJson(JSON.toJSONString(toWmsDTO))
//                                        .build()
//                                        .doPost();
//                            }catch (Exception e){
//                                log.error("wms通讯失败,"+e.getMessage());
//                                continue;
//                            }
//                            apiLogService.save("wms请求入库货位接口"
//                                    ,wmsUrl+"wcsManager/wcsInterface/inboundTaskApply"
//                                    ,null
//                                    ,"127.0.0.1"
//                                    ,JSON.toJSONString(toWmsDTO)
//                                    ,response
//                                    ,true
//                            );
//                            JSONObject jsonObject = JSON.parseObject(response);
//                            if (jsonObject.getInteger("code").equals(200)) {
//                                GetWmsDto getWmsDto = JSON.parseObject(jsonObject.get("data").toString(), GetWmsDto.class);
//                                taskWrk.setOriginTargetPoint(getWmsDto.getTargetLocationCode());
//                                taskWrk.setTargetPoint(Utils.getWcsLocNo(getWmsDto.getTargetLocationCode()));
//                                taskWrk.setStartPoint(String.valueOf(inSta.getBackSta()));
//                                if (!taskWrkService.updateById(taskWrk)){
//                                    log.error("保存wms库位号失败");
//                                }
//
//                            }else {
//                                log.error("wms通讯失败,"+jsonObject.get("msg"));
//
//                            }
//                        }
                        } else {
                            // 退回
                            log.error("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);

                            staProtocol.setWorkNo((short)9999);
                            staProtocol.setStaNo(inSta.getStaNo().shortValue());
                            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);
                            }
                        }
                    }

@@ -371,24 +393,48 @@
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
                List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnSlave.getId()).eq("crn_stn", crnStn.getStaNo()));
                for (StaDesc staDesc : staDescs){
                    // 获取堆垛机出库站信息
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                    StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == 0)) {
                        // 查询工作档
                        TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), staDesc.getStnNo().toString());
                        if (taskWrk == null) {
                    try{
                        // 获取堆垛机出库站信息
                        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                        StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                        if (staProtocol == null) {
                            continue;
                        } else {
                            staProtocol = staProtocol.clone();
                        }
                        siteController.siteDetlUpdate(Integer.valueOf(taskWrk.getTargetPoint()),taskWrk.getWrkNo().shortValue(),(short)0,"Y",false,false);
                        taskWrk.setStatus(5);
                        taskWrk.setWrkSts(14);
                        taskWrkService.updateById(taskWrk);
                        if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == 0)) {
                            // 查询工作档
                            TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), staDesc.getStnNo().toString());
                            if (taskWrk == null) {
                                continue;
                            }
                            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().shortValue());
                            staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
                            boolean offer = false;
                            try{
                                offer = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
                            }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));
                                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));
//                                log.error("下发输送线任务失败：异常信息:"+JSON.toJSONString(r));
                            }
                        }
                    }catch (Exception e){
                        log.error("出库到出库站异常:异常信息："+e);
                    }
                }

@@ -410,6 +456,9 @@
                log.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
                continue;
            }

            // 库位移转
            this.locToLoc(crn, crnProtocol);

            // 只有当堆垛机空闲 并且 无任务时才继续执行
            if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO
@@ -435,8 +484,6 @@
                    }
                }
            }
            // 库位移转
            this.locToLoc(crn, crnProtocol);

        }
    }
@@ -487,15 +534,16 @@
                    continue;
                }

                int workNo = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
                taskWrk.setWrkNo(workNo);//工作号
//                int workNo = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
//                taskWrk.setWrkNo(workNo);//工作号
                Date now = new Date();
                taskWrk.setStatus(TaskStatusType.DISTRIBUTE.id);//派发状态
                taskWrk.setAssignTime(new Date());//派发时间
//                taskWrk.setAssignTime(now);//派发时间
                taskWrk.setExecuteTime(now);
                taskWrk.setWrkSts(3);//工作状态 3.吊车入库
                taskWrk.setCrnNo(staDesc.getCrnNo());//堆垛机号
                taskWrk.setModiTime(new Date());
                taskWrk.setModiTime(now);
                taskWrk.setModiUser(9988L);
                taskWrkService.updateById(taskWrk);

//                //取出命令
//                List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
@@ -540,11 +588,17 @@
                crnCommand.setDestinationPosX(Utils.getRowShort(taskWrk.getTargetPoint()));     // 目标库位列
                crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint()));     // 目标库位层
                crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint()));     // 目标库位排
                crnCommand.setCommand((short)1);
//                crnCommand.setCommand((short)0);
                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand),false)) {
                    log.error("堆垛机命令生成失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                    throw new CoolException("堆垛机命令生成失败");
                }else{
                    try{
                        taskWrkService.updateById(taskWrk);
                    }catch (Exception e){
                        log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", taskWrk.getWrkNo());
                        log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，异常："+e);
                    }
                    try{
                        HashMap<String, Object> headParam = new HashMap<>();
                        headParam.put("taskNo",taskWrk.getTaskNo());
@@ -568,9 +622,9 @@
                                ,response
                                ,true
                        );
                    }catch (Exception e){
                        log.error("wcs派发入库任务上报wms失败", taskWrk);
                        throw new CoolException("wcs派发入库任务上报wms失败");
                    } catch (Exception e){
                        log.error("wcs派发入库任务上报wms失败", JSON.toJSONString(taskWrk));
//                        throw new CoolException("wcs派发入库任务上报wms失败");
                    }

                }
@@ -634,15 +688,6 @@
                            break;
                        }


                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                        Date now = new Date();
                        taskWrk.setWrkSts(12);
                        taskWrk.setStatus(2);
                        taskWrk.setModiTime(now);
                        if (taskWrkMapper.updateById(taskWrk) == 0) {
                            log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                        }
                        CrnCommand command = new CrnCommand();
                        command.setCrnNo(taskWrk.getCrnNo()); // 堆垛机编号
                        command.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
@@ -660,6 +705,20 @@
                            throw new CoolException("堆垛机命令生成失败");
                        }else{
                            try{
                                // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                                Date now = new Date();
                                taskWrk.setWrkSts(12);
                                taskWrk.setStatus(2);
                                taskWrk.setModiTime(now);
                                taskWrk.setExecuteTime(now);
                                if (taskWrkMapper.updateById(taskWrk) == 0) {
                                    log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                                }
                            }catch (Exception e){
                                log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                                log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，异常："+e);
                            }
                            try{
                                HashMap<String, Object> headParam = new HashMap<>();
                                headParam.put("taskNo",taskWrk.getTaskNo());
                                headParam.put("status",taskWrk.getStatus());
@@ -674,7 +733,7 @@
                                        .build()
                                        .doPost();
                                JSONObject jsonObject = JSON.parseObject(response);
                                apiLogService.save("wcs派发入库任务上报wms"
                                apiLogService.save("wcs派发出库任务上报wms"
                                        ,wmsUrl+taskStatusFeedbackPath
                                        ,null
                                        ,"127.0.0.1"
@@ -683,60 +742,10 @@
                                        ,true
                                );
                            }catch (Exception e){
                                log.error("wcs派发出库任务上报wms失败", taskWrk);
                                throw new CoolException("wcs派发入库任务上报wms失败");
                                log.error("wcs派发出库任务上报wms失败", JSON.toJSONString(taskWrk));
//                                throw new CoolException("wcs派发入库任务上报wms失败");
                            }

                        }

//                        // 双深库位且浅库位有货，则需先对浅库位进行库位移转
//                        if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
//
//                            taskWrkMapper.selectPakOutIoType(taskWrk.getCrnNo());
//
//                            List<TaskWrk> taskWrks1 = taskWrkMapper.selectPakOutIoType(taskWrk.getCrnNo());
//                            if (Cools.isEmpty(taskWrks1) && taskWrks1.size()!=0){
//                                continue;
//                            }
//                            String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
//                            TaskWrk hallowLocNoTask = taskWrkMapper.selectByStartPoint(shallowLocNo);
//                            if (!Cools.isEmpty(hallowLocNoTask)){
//                                continue;
//                            }
//                        }
//
//                        //取出命令
//                        List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
//                        Integer commandStep = taskWrk.getCommandStep();
//                        if (commandInfos.isEmpty()) {
//                            continue;//命令空
//                        }
//
//                        //判断末端命令是否执行
//                        CommandInfo commandInfo2 = commandInfos.get(commandInfos.size() - 1);
//                        if (commandInfo2.getCommandStatus() != CommandStatusType.CREATE.id) {
//                            continue;//指令已执行
//                        }
//
//                        CommandInfo commandInfo = commandInfos.get(commandStep);
//                        CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
//                        CrnCommand crnCommand = JSON.parseObject(commandPackage.getCommand().toString(), CrnCommand.class);
//
//                        if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
//                            log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
//                        } else {
//
//                            //开始运行
//                            String response = CrnStartRunning(taskWrk);
//                            JSONObject jsonObject = JSON.parseObject(response);
//                            if (jsonObject.getInteger("code").equals(200)) {
//
//                            }else {
//                                log.error("出库开始运行通讯失败,"+jsonObject.get("msg"));
//
//                            }
//                        }

                    }
                }
            }
@@ -752,7 +761,8 @@
            List<TaskWrk> taskWrks = taskWrkMapper.selectList(new EntityWrapper<TaskWrk>()
                    .eq("crn_no",slave.getId())
                    .eq("wrk_sts",11)
                    .eq("io_type",3));
                    .eq("io_type",3)
                    .orderBy("io_pri",false));
            for (TaskWrk taskWrk : taskWrks){

                // 双深库位且浅库位有货，则需先对浅库位进行库位移转
@@ -808,6 +818,7 @@
                    taskWrk.setWrkSts(12);
                    taskWrk.setStatus(2);
                    taskWrk.setModiTime(now);
                    taskWrk.setExecuteTime(now);
                    if (taskWrkMapper.updateById(taskWrk) == 0) {
                        log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                    }
@@ -835,8 +846,8 @@
                                ,true
                        );
                    }catch (Exception e){
                        log.error("wcs派发出库任务上报wms失败", taskWrk);
                        throw new CoolException("wcs派发入库任务上报wms失败");
                        log.error("wcs派发移库库任务上报wms失败", taskWrk);
//                        throw new CoolException("wcs派发移库库任务上报wms失败");
                    }

                }
@@ -916,17 +927,18 @@
                //确认完成信号
                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(taskWrk.getIoType()==1 && taskWrk.getWrkSts()==3){
                        taskWrk.setWrkSts(4);//入库完成
                        taskWrk.setStatus(5);//完结
                        //更新库位状态
                        LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
                        locMast.setLocSts("F");//F.在库
                        locMast.setBarcode(taskWrk.getBarcode());//托盘码
                        locMast.setModiTime(new Date());
                        locMast.setModiTime(now);
                        locMast.setModiUser(9999L);
                        locMastService.updateById(locMast);
                    }else if(taskWrk.getIoType()==2&&taskWrk.getWrkSts()==12){
@@ -936,7 +948,7 @@
                        LocMast locMast = locMastService.selectByLocNo(taskWrk.getStartPoint());
                        locMast.setLocSts("O");//O.空库位
                        locMast.setBarcode("");//托盘码
                        locMast.setModiTime(new Date());
                        locMast.setModiTime(now);
                        locMast.setModiUser(9999L);
                        locMastService.updateById(locMast);
                    }else if(taskWrk.getIoType()==3&&taskWrk.getWrkSts()==12){
@@ -946,17 +958,19 @@
                        LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
                        locMast.setLocSts("F");//F.在库
                        locMast.setBarcode(taskWrk.getBarcode());//托盘码
                        locMast.setModiTime(new Date());
                        locMast.setModiTime(now);
                        locMast.setModiUser(9999L);
                        locMastService.updateById(locMast);

                        LocMast locMast1 = locMastService.selectByLocNo(taskWrk.getStartPoint());
                        locMast1.setLocSts("O");//O.空库位
                        locMast1.setBarcode("");//托盘码
                        locMast1.setModiTime(new Date());
                        locMast1.setModiTime(now);
                        locMast1.setModiUser(9999L);
                        locMastService.updateById(locMast1);
                    }
                    taskWrk.setModiTime(now);
                    taskWrk.setCompleteTime(now);
                    taskWrkService.updateById(taskWrk);


@@ -967,6 +981,8 @@
                        headParam.put("ioType",taskWrk.getIoType());
                        headParam.put("barcode",taskWrk.getBarcode());
                        String response;
                        log.error("wcs完结任务上报wms==》", headParam);

                        response = new HttpHandler.Builder()
                                // .setHeaders(headParam)
                                .setUri(wmsUrl)
@@ -974,7 +990,11 @@
                                .setJson(JSON.toJSONString(headParam))
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        log.error("wcs完结任务上报wms==》", response);

//                        JSONObject jsonObject = JSON.parseObject(response);
//                        log.error("wcs完结任务上报wms==》", jsonObject);

                        apiLogService.save("wcs派发入库任务上报wms"
                                ,wmsUrl+taskStatusFeedbackPath
                                ,null
@@ -985,7 +1005,8 @@
                        );
                    }catch (Exception e){
                        log.error("wcs完结任务上报wms失败", taskWrk);
                        throw new CoolException("wcs派发入库任务上报wms失败");
                        log.error("wcs完结任务上报wms失败,报错信息：", e);
//                        throw new CoolException("wcs派发入库任务上报wms失败");
                    }
                }

@@ -1135,6 +1156,12 @@
    //agv取放货任务完成
    public synchronized void autoCompleteAGV() {
        List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<>());
        try{
            Thread.sleep(500);
        }catch (Exception e){

        }

        for (BasDevp basDevp:basDevps){
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
            StaProtocol staProtocol = devpThread.getStation().get(basDevp.getDevNo());
@@ -1148,18 +1175,38 @@
                    staProtocol.setAgvTypeSign((short)0);
                    staProtocol.setStaNo(basDevp.getDevNo().shortValue());
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
                }else if (basDevp.getAgvTargetPlace()!=0){
                    staProtocol.setAgvTypeSign((short)1);
                }
                boolean sign = true;
                if (basDevp.getAgvTargetPlace()!=0){
                    sign = false;
                    basDevp.setAgvTargetPlace(0);
                    basDevpService.updateById(basDevp);
                    staProtocol.setAgvTypeSign((short)3);//1
                    staProtocol.setStaNo(basDevp.getDevNo().shortValue());
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
                }
            }else {
                if (basDevp.getAgvTargetPlace()!=0){
                    if (basDevp.getLoading().equals("Y")){
                        staProtocol.setAgvTypeSign((short)1);
                        staProtocol.setStaNo(basDevp.getDevNo().shortValue());
                        MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
                    }else {
                        log.error("AGV放货完成但输送线无物，复位信号 ===>> [staNo:{}] [basDevp:{}]", basDevp.getDevNo(), basDevp);
                        basDevp.setAgvTargetPlace(0);
                        basDevpService.updateById(basDevp);
                        staProtocol.setAgvTypeSign((short)3);//1
                        staProtocol.setStaNo(basDevp.getDevNo().shortValue());
                        MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
                    }

                }
                if (basDevp.getAgvTargetPick()!=0){
                    basDevp.setAgvStartPick(0);
                    basDevp.setAgvTargetPick(0);
                    basDevpService.updateById(basDevp);
                }else if (basDevp.getAgvTargetPlace()!=0){
                    basDevp.setAgvStartPlace(0);
                    basDevpService.updateById(basDevp);
                    staProtocol.setAgvTypeSign((short)2);//0
                    staProtocol.setStaNo(basDevp.getDevNo().shortValue());
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
                }
            }
        }
@@ -1290,6 +1337,9 @@
        taskWrk.setWrkNo(workNo1);
        taskWrk.setStatus(TaskStatusType.RECEIVE.id);//任务状态：接收
        taskWrk.setCreateTime(now);
        taskWrk.setAssignTime(now);
        taskWrk.setModiTime(now);
        taskWrk.setModiUser(5555L);
        taskWrk.setIoType(1);//任务类型
        taskWrk.setIoPri(Cools.isEmpty(dto.getTaskPriority()) ? 300 : Integer.parseInt(dto.getTaskPriority()));//优先级
        taskWrk.setBarcode(barcode);//条码