*

lsh

2025-04-01 0c60480362efdcffa0cbb3f6dd4272f43859adb1

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

@@ -56,8 +56,6 @@
@Transactional
public class MainServiceImpl {

    public static final long COMMAND_TIMEOUT = 5 * 1000;

    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
@@ -77,14 +75,8 @@
    @Autowired
    private TaskWrkService taskWrkService;
    @Autowired
    private ConfigService configService;
    @Autowired
    private StaDescMapper staDescMapper;
    @Autowired
    private CommandInfoService commandInfoService;

    @Autowired
    private OpenServiceImpl openServiceImpl;
    @Autowired
    private StaDescService staDescService;

@@ -103,8 +95,6 @@
    private String taskStatusFeedbackPath;
    @Autowired
    private CrnController crnController;
    @Autowired
    private SiteController siteController;


    public void generateStoreWrkFile() throws IOException, InterruptedException {
@@ -176,6 +166,7 @@
                        TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
                        if (taskWrk != null) {
                            taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
                            taskWrk.setModiTime(new Date());
                            taskWrkMapper.updateById(taskWrk);
                        }
                        continue;
@@ -322,7 +313,7 @@
                                                .build()
                                                .doPost();
                                        JSONObject jsonObject1 = JSON.parseObject(response2);
                                        apiLogService.save("wcs派发库位不为空上报wms"
                                        apiLogService.save("wcs派发库位==》不为空《==上报wms"
                                                ,wmsUrl+taskStatusFeedbackPath
                                                ,null
                                                ,"127.0.0.1"
@@ -331,8 +322,8 @@
                                                ,true
                                        );
                                    }catch (Exception e){
                                        log.error("wcs派发库位不为空上报wms", getWmsDto.getWrkNo());
                                        throw new CoolException("wcs派发入库任务上报wms失败，异常信息："+e);
                                        log.error("wcs派发库位==》不为空《==上报wms", getWmsDto.getWrkNo());
                                        throw new CoolException("wcs派发入库任务上报wms失败,派发库位==》不为空《==，异常信息："+e);
                                    }
                                }

@@ -367,6 +358,7 @@
                            TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
                            if (taskWrk != null) {
                                taskWrk.setMemo(errMsg);//将错误码存入备注字段进行展示
                                taskWrk.setModiTime(new Date());
                                taskWrkMapper.updateById(taskWrk);
                            }
                        }
@@ -407,16 +399,28 @@
                                continue;
                            }
                            log.info("下发输送线任务：taskWrk:"+JSON.toJSONString(taskWrk));
                            R r = siteController.siteDetlUpdate(Integer.valueOf(taskWrk.getTargetPoint()), taskWrk.getWrkNo().shortValue(), (short) 0, "Y", false, false);
                            JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(r));
                            if (jsonObject.getInteger("code").equals(200)){
//                            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));
//                                log.error("下发输送线任务失败：异常信息:"+JSON.toJSONString(r));
                            }
                        }
                    }catch (Exception e){
@@ -443,6 +447,9 @@
                continue;
            }

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

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

        }
    }
@@ -519,15 +524,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());
@@ -578,6 +584,12 @@
                    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());
                        headParam.put("status",taskWrk.getStatus());
@@ -600,9 +612,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失败");
                    }

                }
@@ -666,15 +678,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()); // 工作号
@@ -692,6 +695,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());
@@ -706,7 +723,7 @@
                                        .build()
                                        .doPost();
                                JSONObject jsonObject = JSON.parseObject(response);
                                apiLogService.save("wcs派发入库任务上报wms"
                                apiLogService.save("wcs派发出库任务上报wms"
                                        ,wmsUrl+taskStatusFeedbackPath
                                        ,null
                                        ,"127.0.0.1"
@@ -715,60 +732,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"));
//
//                            }
//                        }

                    }
                }
            }
@@ -784,7 +751,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){

                // 双深库位且浅库位有货，则需先对浅库位进行库位移转
@@ -840,6 +808,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());
                    }
@@ -867,8 +836,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失败");
                    }

                }
@@ -881,54 +850,6 @@
    /**
     * 执行对工作档的完成操作
     */
//    public void storeFinished() {
//        for (CrnSlave crn : slaveProperties.getCrn()) {
//            // 获取堆垛机信息
//            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
//            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
//            if (crnProtocol == null) { continue; }
//
//            //  状态：等待确认 并且  任务完成位 = 1
//            if (crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.getTaskNo() != 0) {
//                //获取入库待确认工作档
//                TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crn.getId(),crnProtocol.getTaskNo().intValue());
//                if (Cools.isEmpty(taskWrk)) {
////                    log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
//                    continue;
//                }
//
//                //获取指令ID
//                Integer commandId = crnProtocol.getCommandId();
//                CommandInfo commandInfo = new CommandInfo();
//                if (Cools.isEmpty(commandId)){
//                    commandInfo = commandInfoService.selectOne(new EntityWrapper<CommandInfo>()
//                            .eq("wrk_no",crnProtocol.getTaskNo())
//                            .eq("device","Crn"));
//                }else {
//                    commandInfo = commandInfoService.selectById(commandId);
//                }
//
//
//                if (commandInfo == null) {
//                    //指令不存在
//                    continue;
//                }
//                if (commandInfo.getCommandStatus() == 3){
//                    continue;
//                }
//                commandInfo.setCommandStatus(CommandStatusType.COMPLETE.id);//指令完成
//                commandInfo.setCompleteTime(new Date());//指令完成时间
//                if (commandInfoService.updateById(commandInfo)) {//修改成功后复位堆垛机
//                    // 堆垛机复位
//                    crnThread.setResetFlag(true);
//                }
//            }
//        }
//    }

    /**
     * 执行对工作档的完成操作
     */
    public void storeFinished() throws InterruptedException {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
@@ -937,7 +858,7 @@
            if (crnProtocol == null) { continue; }

            //  状态：等待确认 并且  任务完成位 = 1
            if (crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.getTaskNo() != 0) {
            if (!Cools.isEmpty(crnProtocol.getTaskFinish()) && crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
                //获取入库待确认工作档
                TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crn.getId(),crnProtocol.getTaskNo().intValue());
                if (Cools.isEmpty(taskWrk)&&crnProtocol.getTaskNo() !=999) {
@@ -948,6 +869,7 @@
                //确认完成信号
                CrnOperatorParam crnOperatorParam=new CrnOperatorParam();
                crnOperatorParam.setCrnNo(crn.getId());
                Date now = new Date();

                crnController.crnTaskComplete(crnOperatorParam);
                if(!Cools.isEmpty(taskWrk)){
@@ -958,7 +880,7 @@
                        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){
@@ -968,7 +890,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){
@@ -978,17 +900,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);


@@ -1072,7 +996,7 @@
                                    wrkMast.getSourceStaNo(),    // 源站
                                    wrkMast.getSourceLocNo(),    // 源库位
                                    wrkMast.getBarcode(),    // 条码
                                    (int) crnProtocol.getAlarm1(),    // 异常码
                                    (int) crnProtocol.getAlarm(),    // 异常码
                                    errName,    // 异常
                                    1,    // 异常情况
                                    now,    // 添加时间
@@ -1087,7 +1011,7 @@
                        }
                    } else {
                        // 异常修复
                        if (crnProtocol.getAlarm1() == null || crnProtocol.getAlarm1() == 0) {
                        if (crnProtocol.getAlarm() == null || crnProtocol.getAlarm() == 0) {
                            latest.setEndTime(now);
                            latest.setUpdateTime(now);
                            latest.setStatus(2);
@@ -1100,7 +1024,7 @@
                } else {
                    BasErrLog latest = basErrLogService.findLatest(crn.getId());
                    // 有异常
                    if (crnProtocol.getAlarm1() != null && crnProtocol.getAlarm() > 0) {
                    if (crnProtocol.getAlarm() != null && crnProtocol.getAlarm() > 0) {
                        // 记录新异常
                        if (latest == null || (latest.getErrCode() != crnProtocol.getAlarm().intValue())) {
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
@@ -1119,7 +1043,7 @@
                                    null,    // 源站
                                    null,    // 源库位
                                    null,    // 条码
                                    (int)crnProtocol.getAlarm1(),    // 异常码
                                    (int)crnProtocol.getAlarm(),    // 异常码
                                    errName,    // 异常
                                    1,    // 异常情况
                                    now,    // 添加时间
@@ -1150,199 +1074,6 @@
        }
    }

    //自动派发任务
    public void autoDistribute() {
        Config config = configService.selectByCode("autoDistribute");
        if (config == null) {
            return;
        }

        if (config.getValue().equals("false")) {//判断是否开启自动派发任务
            return;
        }

        for (TaskWrk taskWrk : taskWrkService.selectReceive()) {

            try {
                taskWrkService.distribute(taskWrk.getTaskNo(), 9527L);
            } catch (CoolException e) {
                log.info(e.getMessage());
            }
        }
    }

    //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());
            if (staProtocol == null) {
                continue;
            } else {
                staProtocol = staProtocol.clone();
            }
            if (basDevp.getWrkNo()!=0){
                if (basDevp.getAgvTargetPick()!=0){//取货
                    staProtocol.setAgvTypeSign((short)0);
                    staProtocol.setStaNo(basDevp.getDevNo().shortValue());
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
                }
                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.setAgvTargetPick(0);
                    basDevpService.updateById(basDevp);
                    staProtocol.setAgvTypeSign((short)2);//0
                    staProtocol.setStaNo(basDevp.getDevNo().shortValue());
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
                }
            }
        }
    }
    public synchronized void autoCompleteTask() {
        List<TaskWrk> taskWrks = taskWrkMapper.selectWorkingTask();
        for (TaskWrk taskWrk : taskWrks) {
            //获取命令集合
            List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
            if (taskWrk.getCommandStep() < commandInfos.size()) {
                continue;//当前步序没有到达最后一条命令
            }

            //判断末端命令是否执行完成
            CommandInfo commandInfo = commandInfos.get(commandInfos.size() - 1);
            if (commandInfo.getCommandStatus() != CommandStatusType.COMPLETE.id) {
                continue;//指令未完成
            }

            Date now = new Date();
            //指令已完成，更新任务
            if (taskWrk.getIoType() == 1) {
                //入库任务
                taskWrk.setWrkSts(4);//3.吊车入库中 => 4.入库完成
                //taskWrk.setStatus(TaskStatusType.COMPLETE.id);
                taskWrk.setModiTime(now);
                taskWrkService.updateById(taskWrk);

                //更新库位状态
                LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
                locMast.setLocSts("F");//F.在库
                locMast.setBarcode(taskWrk.getBarcode());//托盘码
                locMast.setModiTime(now);
                locMast.setModiUser(9999L);
                locMastService.updateById(locMast);
            } else if (taskWrk.getIoType() == 2) {
                //出库任务
                taskWrk.setWrkSts(14);//12.吊车出库中 => 14.出库完成
//                taskWrk.setStatus(TaskStatusType.COMPLETE.id);
                taskWrk.setModiTime(now);
                taskWrkService.updateById(taskWrk);

                //更新库位状态
                LocMast locMast = locMastService.selectByLocNo(taskWrk.getStartPoint());
                locMast.setLocSts("O");//O.空库位
                locMast.setBarcode("");//托盘码
                locMast.setModiTime(now);
                locMast.setModiUser(9999L);
                locMastService.updateById(locMast);
            }
        }
    }


    public synchronized String CrnStartRunning(TaskWrk taskWrk){
        String tasktype = null;
        switch (taskWrk.getIoType()){
            case 1:
                tasktype= "RK";
                break;
            case 2:
                tasktype= "CK";
                break;
            case 3:
                tasktype= "YK";
                break;
            default:
                tasktype= "未知";
        }
        Map<String, Object> map = new HashMap<>();
        map.put("x-api-key","7a15b5db-29b6-552c-8cff-0cfec3756da2");
        TaskOverToWms taskOverToWms = new TaskOverToWms();
        taskOverToWms.setFeedbackFrom("WCS"); //来源
        taskOverToWms.setWarehouseId("1688469798893297665"); //仓库标识
        taskOverToWms.setTaskNo(taskWrk.getTaskNo()); //任务号
        taskOverToWms.setTaskType(tasktype); // 任务类型
        taskOverToWms.setContainerCode(taskWrk.getBarcode()); // 容器编码
        if (taskWrk.getIoType() ==1 || taskWrk.getIoType() == 3){
            taskOverToWms.setEquipmentCode(String.valueOf(taskWrk.getCrnNo())); //设备编码
            taskOverToWms.setTargetLocationCode(taskWrk.getOriginTargetPoint()); //目标库位
        }else if (taskWrk.getIoType() ==2){
            Map<Integer,String> map1 = new HashMap<>();
            map1.put(102,"J-1101");
            map1.put(106,"J-1103");
            map1.put(110,"J-1105");
            map1.put(114,"J-1107");
            map1.put(118,"J-1109");
            map1.put(122,"J-1111");
            map1.put(305,"H-1101");
            map1.put(405,"G-1101");
            taskOverToWms.setEquipmentCode(map1.get(taskWrk.getTargetPoint())); //设备编码
            taskOverToWms.setSourceLocationCode(taskWrk.getOriginStartPoint()); //源库位
        }

        taskOverToWms.setTaskStatus("executing"); //任务状态
        String response = null;
        try {
            response = new HttpHandler.Builder()
                    .setHeaders(map)
                    .setUri(wmsUrl)
                    .setPath("wcsManager/wcsInterface/taskStatusFeedback")
                    .setJson(JSON.toJSONString(taskOverToWms))
                    .build()
                    .doPost();
        }catch (Exception e){
            log.error("堆垛机任务完成，请求wms任务完成接口失败");
        }
        apiLogService.save("堆垛机开始运行"
                ,wmsUrl+"wcsManager/wcsInterface/taskStatusFeedback"
                ,null
                ,"127.0.0.1"
                ,JSON.toJSONString(taskOverToWms)
                ,response
                ,true
        );
        return response;
    }

    private TaskWrk createTask(GetWmsDto dto, String barcode){
        String wcsLocNo = dto.getLocNo();
        if(Cools.isEmpty(wcsLocNo)){
@@ -1355,6 +1086,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);//条码