#

Junjie

2 天以前 aa641ae9531ff38a80316cb4f72fa8ece43d7029

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

@@ -2,42 +2,47 @@

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.domain.dto.NotifyCustomDataDto;
import com.zy.asrs.domain.enums.NotifyMsgType;
import com.zy.asrs.domain.enums.TaskStatusType;
import com.zy.asrs.domain.enums.WorkNoType;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.WMSAndAGVInterfaceParam;
import com.zy.asrs.mapper.BasCrnErrorMapper;
import com.zy.asrs.mapper.TaskWrkMapper;
import com.zy.asrs.mapper.WaitPakinMapper;
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.entity.param.Result;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.CommandUtils;
import com.zy.asrs.utils.PostMesDataUtils;
import com.zy.asrs.utils.CrnOperaUtils;
import com.zy.asrs.utils.NotifyUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
import com.zy.core.CrnThread;
import com.zy.core.DevpThread;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.*;
import com.zy.core.model.CrnSlave;
import com.zy.core.model.DevpSlave;
import com.zy.core.model.Task;
import com.zy.core.model.command.CrnCommand;
import com.zy.core.model.protocol.CrnProtocol;
import com.zy.core.model.protocol.StaProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.BarcodeThread;
import com.zy.core.thread.SiemensDevpThread;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.Date;
import java.util.List;
import java.io.IOException;
import java.util.*;

/**
 * 立体仓库WCS系统主流程业务
@@ -70,70 +75,526 @@
    private TaskWrkService taskWrkService;
    @Autowired
    private ConfigService configService;

    @Autowired
    private StaDescMapper staDescMapper;
    @Autowired
    private CommandInfoService commandInfoService;
    @Autowired
    private OpenServiceImpl openServiceImpl;
    @Autowired
    private StaDescService staDescService;
    @Autowired
    private ApiLogService apiLogService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private CrnOperaUtils crnOperaUtils;
    @Autowired
    private NotifyUtils notifyUtils;
    @Value("${wms.count}")
    private Integer maxCount;
    @Autowired
    private WrkMastService wrkMastService;
    @Value("${wms.url}")
    private String wmsUrl;
    @Value("${wms.movePath}")
    private String movePath;
    @Value("${wms.inboundTaskApplyPath}")
    private String inboundTaskApplyPath;
    @Value("${wms.TaskExecCallback}")
    private String TaskExecCallback;
    @Value("${wms.taskStatusFeedbackPath}")
    private String taskStatusFeedbackPath;

    public synchronized void generateStoreWrkFile1() {
        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();
                    }
                    Short workNo = staProtocol.getWorkNo();
                    Short 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 && staProtocol.isBarcodeErr()) {
                        errMsg = "扫码失败";
                        back = true;
                    }
                    // 判断是否满足入库条件
                    if (staProtocol.isAutoing() && staProtocol.isLoading()
                            && staProtocol.isInEnable()
                            && !staProtocol.isEmptyMk() && workNo >= 9790
                            && staProtocol.isPakMk()) {
                        // 获取条码扫描仪信息
                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
                        if (barcodeThread == null) {
                            continue;
                        }

                        String barcode = barcodeThread.getBarcode();
                        TaskWrk taskWrk1 = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", barcode));
                        if (taskWrk1 != null) {
                            log.info("托盘码：" + barcode + "任务档存在");
                            continue;
                        }

                        HashMap<String, Object> requestParam = new HashMap<>();
                        requestParam.put("BoxNo", barcode);//托盘码
                        requestParam.put("TerminalNo", inSta.getStaNo());//入库口
                        if (back) {
                            requestParam.put("WCSStatus", 1);//失败
                            requestParam.put("WCSErrorMessage", errMsg);//失败原因
                        }else {
                            requestParam.put("WCSStatus", 0);//成功
                        }

                        String response = "";
                        Boolean success = false;
                        try {
                            response = new HttpHandler.Builder()
                                    .setUri(wmsUrl)
                                    .setPath(inboundTaskApplyPath)
                                    .setJson(JSON.toJSONString(requestParam))
                                    .build()
                                    .doPost();
                            JSONObject jsonObject = JSON.parseObject(response);

                            if (back) {
                                devpThread.setPakMk(staProtocol.getSiteId(), false);
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                continue;
                            }

                            int returnStatus = Integer.parseInt(jsonObject.get("ReturnStatus").toString());
                            if (returnStatus == 0) {
                                Result result = JSON.parseObject(jsonObject.get("Result").toString(), Result.class);
                                // 创新一个入库工作档
                                TaskWrk taskWrk = taskWrkService.selectByTaskNo(result.getTaskNo());
                                if(taskWrk != null) {
                                    log.info("任务：" + result.getTaskNo() + "已经存在");
                                    continue;
                                }

                                taskWrk = createTask1(result, barcode);
                                if (!taskWrkService.insert(taskWrk)) {
                                    log.info("任务：" + result.getTaskNo() + "任务创建失败");
                                    continue;
                                }

                                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().shortValue());
                                staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                                //上报
                                HashMap<String, Object> hashMap = new HashMap<>();
                                hashMap.put("TaskNo", taskWrk.getTaskNo());

                                NotifyCustomDataDto customDataDto = new NotifyCustomDataDto();
                                customDataDto.setUri(wmsUrl);
                                customDataDto.setPath(taskStatusFeedbackPath);
                                customDataDto.setData(JSON.toJSONString(hashMap));
                                boolean notifyResult = notifyUtils.notify("task", 1, String.valueOf(taskWrk.getWrkNo()), taskWrk.getTaskNo(), NotifyMsgType.TASK_START, JSON.toJSONString(taskWrk), true, customDataDto);
                                if(notifyResult) {
                                    taskWrk.setStatus(2);
                                    taskWrkService.updateById(taskWrk);
                                }
                            }
                        } 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);
                            }
                        } finally {
                            apiLogService.save("wms请求入库货位接口"
                                    , wmsUrl + inboundTaskApplyPath
                                    , null
                                    , "127.0.0.1"
                                    , JSON.toJSONString(requestParam)
                                    , response
                                    , success
                            );
                        }
                        log.info("入库请求参数=" + JSON.toJSONString(barcode));
                        log.info("入库请求返回参数=" + JSON.toJSONString(response));
                    }
                }
            }
        } catch (Exception e) {
            log.error("generateStoreWrkFile e", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

    public synchronized void generateStoreWrkFile() throws IOException, InterruptedException {
        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();
                    }
                    Short workNo = staProtocol.getWorkNo();
                    Short 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 && staProtocol.isBarcodeErr()) {
                        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().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;
                    }
                    // 判断是否满足入库条件
                    if (staProtocol.isAutoing() && staProtocol.isLoading()
                            && staProtocol.isInEnable()
                            && !staProtocol.isEmptyMk() && (workNo >= 9899)
                            && staProtocol.isPakMk()) {
                        // 获取条码扫描仪信息
                        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(), 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())) {
                                    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");
                            System.out.println(JSON.toJSONString(toWmsDTO));
                            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((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);
                            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")
                                        .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().shortValue());
                                        staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                    }
                                }

                            } else {
                                continue;
                            }
                            apiLogService.save("wms请求入库货位接口"
                                    , wmsUrl + inboundTaskApplyPath
                                    , null
                                    , "127.0.0.1"
                                    , JSON.toJSONString(toWmsDTO)
                                    , response
                                    , true
                            );

                        } 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);//将错误码存入备注字段进行展示
                                taskWrkMapper.updateById(taskWrk);
                            }
                        }
                    }


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


    /**
     * 堆垛机站出库到出库站
     */
    @Async
    public void crnStnToOutStn() {
    public synchronized void crnStnToOutStn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
                // 获取堆垛机出库站信息
                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() == null)) {
                    // 查询工作档
                    TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), staProtocol.getSiteId().toString());
                    if (taskWrk == null) {
                        continue;
                    }
                    // 判断工作档条件
                    if (taskWrk.getWrkSts() == 12 && taskWrk.getIoType() == 2) {
                        // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                        CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, taskWrk.getCrnNo());
                        CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                        if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) {
                            // 移动中
                List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnSlave.getId()).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());
                        if (staProtocol == null) {
                            continue;
                        } else {
                            staProtocol = staProtocol.clone();
                        }
                        //  判断堆垛机状态等待确认
                        if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(taskWrk.getWrkNo().shortValue())
                                && crnProtocol.getTaskFinish() == 1
                                && crnProtocol.forkPosType == CrnForkPosType.HOME) {
                            // 命令下发区 --------------------------------------------------------------------------

                            // 下发站点信息
                            staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
                            String targetPoint = taskWrk.getTargetPoint();
                            int i = Integer.parseInt(targetPoint);
                            staProtocol.setStaNo((short)i);
                            if (!CommandUtils.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                        if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == 0)) {
                            // 查询工作档
                            TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), staDesc.getStnNo().toString());
                            if (taskWrk == null) {
                                continue;
                            }

                            // 更新工作档状态为14失败
                            taskWrk.setWrkSts(14);
                            if (taskWrkMapper.updateById(taskWrk) != 0) {
                                // 复位堆垛机
                                crnThread.setResetFlag(true);
                            } else {
                                log.error("更新工作档的工作状态为14失败！！！ [工作号:{}]", taskWrk.getWrkNo());
                            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.getStnNo().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));
                                taskWrk.setStatus(5);
                                taskWrk.setWrkSts(14);
                                taskWrkService.updateById(taskWrk);

                            } else {
                                log.error("下发输送线任务失败：taskWrk:" + JSON.toJSONString(taskWrk));
//                                log.error("下发输送线任务失败：异常信息:"+JSON.toJSONString(r));
                            }
                        }
                    } catch (Exception e) {
                        log.error("出库到出库站异常:异常信息：" + e);
                    }
                }

            }
        }
    }
@@ -141,17 +602,20 @@
    /**
     * 入出库  ===>>  堆垛机入出库作业下发
     */
    public synchronized void crnIoExecute(){
    public synchronized void crnIoExecute() throws IOException {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            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 (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO
@@ -176,9 +640,10 @@
                        crnProtocol.setLastIo("O");
                    }
                }

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

        }
    }
@@ -186,205 +651,39 @@
    /**
     * 入库  ===>>  堆垛机站到库位
     */
    public void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol){
    public synchronized void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol) throws IOException {
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            boolean flag = false;
            // 获取堆垛机入库站信息
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
            StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
            if (staProtocol == null) {
                continue;
            } else {
                staProtocol = staProtocol.clone();
            }
            // 查询站点详细信息
            BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
            if (staDetl == null) {
                log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                continue;
            }
            if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
                    && staDetl.getCanining()!=null && staDetl.getCanining().equals("Y")) {
                flag = true;
            }
            if (!flag) {
                continue;
            }
            // 获取工作状态为2（设备上走）的入库工作档
            TaskWrk taskWrk = taskWrkMapper.selectPakIn(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo().toString());
            if(null == taskWrk) {
                continue;
            }

            // 堆垛机控制过滤
            if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                continue;
            }

            // 已经存在吊车执行任务时，则过滤
            if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                continue;
            }

            // 命令下发区 --------------------------------------------------------------------------
            CrnCommand crnCommand = new CrnCommand();
            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
            crnCommand.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
            crnCommand.setSourcePosX(crnStn.getBay().shortValue());     // 源库位列
            crnCommand.setSourcePosY(crnStn.getLev().shortValue());     // 源库位层
            crnCommand.setSourcePosZ(crnStn.getRow().shortValue());     // 源库位排
            crnCommand.setDestinationPosX(Utils.getBayShort(taskWrk.getTargetPoint()));     // 目标库位列
            crnCommand.setDestinationPosY(Utils.getLevShort(taskWrk.getTargetPoint()));     // 目标库位层
            crnCommand.setDestinationPosZ(Utils.getRowShort(taskWrk.getTargetPoint()));     // 目标库位排
            crnCommand.setCommand((short)1);
            if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
            } else {
                // 修改工作档状态 2.设备上走 => 3.吊车入库中
                Date now = new Date();
                taskWrk.setWrkSts(3);
                taskWrk.setModiTime(now);
                if (taskWrkMapper.updateById(taskWrk) == 0) {
                    log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", taskWrk.getWrkNo());
                }
            }
            return;
        }
    }

    /**
     * 出库  ===>>  库位到堆垛机站
     * 2022-06-09 TQS修改，查询工作档LIST，遍历下发，防止第一个任务堵塞出库
     */
    public void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的出库工作档
            List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(slave.getId(), crnStn.getStaNo().toString());
            for (TaskWrk taskWrk : taskWrks){
                if (taskWrk == null) {
                    continue;
                }
                // 工作档状态判断
                if (taskWrk.getIoType() != 2 || taskWrk.getTargetPoint() == null) {
                    log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", taskWrk.getWrkNo(), taskWrk.getTargetPoint(), taskWrk.getIoType());
                    continue;
                }
                // 获取堆垛机出库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
            for (StaDesc staDesc : staDescs) {
                boolean flag = false;
                // 获取堆垛机入库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                if (staProtocol == null) {
                    break;
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                // 查询站点详细信息
                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                if (staDetl == null) {
                    log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    break;
                }

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

                    // 堆垛机控制过滤
                    if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                        break;
                    }

                    // 已经存在吊车执行任务时，则过滤
                    if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                        break;
                    }

                    // 双深库位且浅库位有货，则需先对浅库位进行库位移转
                    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)){
                            if (!Cools.isEmpty(hallowLocNoTask.getTargetPoint())){
                                continue;
                            }
//                            new PostMesDataUtils().postMesData("移库任务分配库位",wmsUrl,movePath,hallowLocNoTask);
                            try {
                                String response = new HttpHandler.Builder()
                                        .setUri(wmsUrl)
                                        .setPath(movePath)
                                        .setJson(JSON.toJSONString(hallowLocNoTask))
                                        .build()
                                        .doPost();
                                System.out.println("response:"+response);
                                JSONObject jsonObject = JSON.parseObject(response);
                                if (jsonObject.getInteger("code").equals(200)) {
                                    //解析
                                }
                            }catch (Exception e){
                                log.error("请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl+"/"+movePath, JSON.toJSONString(hallowLocNoTask), "请求移库任务分配库位");
                            }
                            continue;
                        }
                    }

                    // 1.堆垛机开始移动
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                    crnCommand.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getRowShort(taskWrk.getStartPoint()));     // 源库位排
                    crnCommand.setSourcePosY(Utils.getBayShort(taskWrk.getStartPoint()));     // 源库位列
                    crnCommand.setSourcePosZ(Utils.getLevShort(taskWrk.getStartPoint()));     // 源库位层
                    crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                    if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
                        log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                        Date now = new Date();
                        taskWrk.setWrkSts(12);
                        taskWrk.setModiTime(now);
                        if (taskWrkMapper.updateById(taskWrk) == 0) {
                            log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                        }
                        break;
                    }
                    return;
                }
            }
        }
    }

    /**
     * 库位移转
     */
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的移库工作档
            List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut3(slave.getId(), crnStn.getStaNo().toString());
            for (TaskWrk taskWrk : taskWrks){
                if (taskWrk == null || Cools.isEmpty(taskWrk.getTargetPoint()) || taskWrk.getTargetPoint().equals("")) {
                    log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    continue;
                }
                // 工作档状态判断
                if (taskWrk.getIoType() != 3 || taskWrk.getTargetPoint() == null) {
                    log.error("查询工作档数据不符合条件--入出类型/目标库位号, 工作号={}，源库位={}，入出类型={}", taskWrk.getWrkNo(), taskWrk.getTargetPoint(), taskWrk.getIoType());
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
                        && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
                    flag = true;
                }
                if (!flag) {
                    continue;
                }

                // 命令下发区 --------------------------------------------------------------------------

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

                // 堆垛机控制过滤
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
@@ -395,6 +694,215 @@
                if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                    continue;
                }

                taskWrk.setAssignTime(new Date());//派发时间
                taskWrk.setWrkSts(3);//工作状态 3.吊车入库
                taskWrk.setCrnNo(staDesc.getCrnNo());//堆垛机号
                taskWrk.setModiTime(new Date());
                taskWrk.setModiUser(9988L);

                // 命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(staDesc.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位列
                crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位层
                crnCommand.setSourcePosZ(crnStn.getLev().shortValue());     // 源库位排
                crnCommand.setDestinationPosX(Utils.getRowShort(taskWrk.getTargetPoint()));     // 目标库位列
                crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint()));     // 目标库位层
                crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint()));     // 目标库位排
                crnCommand.setCommand((short) 1);
                log.info("堆垛机入库任务下发={}",crnCommand);
                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) {
                        e.printStackTrace();
                        log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", taskWrk.getWrkNo());
                    }
                }
            }
        }
    }

    /**
     * 出库  ===>>  库位到堆垛机站
     * 2022-06-09 TQS修改，查询工作档LIST，遍历下发，防止第一个任务堵塞出库
     */
    public synchronized void  locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol) {
        List<TaskWrk> taskWrksInitial = taskWrkMapper.selectPakOut(slave.getId(), null);
        if (taskWrksInitial.isEmpty()) {
            return;
        }
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
            for (StaDesc staDesc : staDescs) {
                // 获取工作状态为11（生成出库ID）的出库工作档
                List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(slave.getId(), staDesc.getStnNo().toString());
                for (TaskWrk taskWrk : taskWrks) {
                    if (taskWrk == null) {
                        continue;
                    }
                    // 工作档状态判断
                    if (taskWrk.getIoType() != 2 || taskWrk.getTargetPoint() == null || taskWrk.getStartPoint() == null) {
                        log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", taskWrk.getWrkNo(), taskWrk.getStartPoint(), taskWrk.getIoType());
                        continue;
                    }

                    LocMast locMast=locMastService.selectByLocNo(taskWrk.getStartPoint());
                    //判断其库位是否为深库位，如果为深库位找其浅库位是都有货
                    if(locMast.getRow1()==1||locMast.getRow1()==5){
                        LocMast locMast1=locMastService.selectOne(new EntityWrapper<LocMast>()
                                .eq("row1", (locMast.getRow1()+1))
                                .eq("bay1",locMast.getBay1())
                                .eq("lev1",locMast.getLev1()).eq("loc_sts","F"));
                        if (!Cools.isEmpty(locMast1)){
                            log.info(locMast.getLocNo()+"出深库位，浅库位有货");
                            continue;
                        }
                    }else if(locMast.getRow1()==4||locMast.getRow1()==8){
                        LocMast locMast1=locMastService.selectOne(new EntityWrapper<LocMast>()
                                .eq("row1", (locMast.getRow1()-1))
                                .eq("bay1",locMast.getBay1())
                                .eq("lev1",locMast.getLev1()).eq("loc_sts","F"));
                        if (!Cools.isEmpty(locMast1)){
                            log.info(locMast.getLocNo()+"出深库位，浅库位有货");
                            continue;
                        }
                    }

                    // 获取堆垛机出库站信息
                    SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                    StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                    if (staProtocol == null) {
                        break;
                    } else {
                        staProtocol = staProtocol.clone();
                    }

                    // 查询站点详细信息
                    BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                    if (staDetl == null) {
                        log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                        break;
                    }

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

                        // 堆垛机控制过滤
                        if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                            break;
                        }
                        int storeCount = basDevpService.getStoreCount();
                        if(storeCount >= maxCount){
                            log.error("输送线暂存数达到上限{}",storeCount);
                            break;
                        }


                        // 已经存在吊车执行任务时，则过滤
                        if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                            break;
                        }
                        CrnCommand command = new CrnCommand();
                        command.setCrnNo(taskWrk.getCrnNo()); // 堆垛机编号
                        command.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
                        command.setAckFinish((short) 0);  // 任务完成确认位
                        command.setTaskMode(CrnTaskModeType.PAKIN); // 任务模式
                        command.setSourcePosX(Utils.getRowShort(taskWrk.getStartPoint()));     // 源库位排
                        command.setSourcePosY(Utils.getBayShort(taskWrk.getStartPoint()));     // 源库位列
                        command.setSourcePosZ(Utils.getLevShort(taskWrk.getStartPoint()));     // 源库位层
                        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("堆垛机命令生成失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(command));
                            throw new CoolException("堆垛机命令生成失败");
                        } else {
                            try {
                                // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                                Date now = new Date();
                                taskWrk.setWrkSts(12);
                                taskWrk.setModiTime(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);
                            }

                            //上报-出库任务开始时，WCS回调WMS
                            HashMap<String, Object> hashMap = new HashMap<>();
                            hashMap.put("TaskNo", taskWrk.getTaskNo());

                            NotifyCustomDataDto customDataDto = new NotifyCustomDataDto();
                            customDataDto.setUri(wmsUrl);
                            customDataDto.setPath(taskStatusFeedbackPath);
                            customDataDto.setData(JSON.toJSONString(hashMap));
                            boolean notifyResult = notifyUtils.notify("task", 1, String.valueOf(taskWrk.getWrkNo()), taskWrk.getTaskNo(), NotifyMsgType.TASK_START, JSON.toJSONString(taskWrk), true, customDataDto);
                            if(notifyResult) {
                                taskWrk.setStatus(2);
                                taskWrkService.updateById(taskWrk);
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * 库位移转
     */
    public synchronized 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", slave.getId())
                    .eq("wrk_sts", 11)
                    .eq("io_type", 3)
                    .orderBy("io_pri", false));
            for (TaskWrk taskWrk : taskWrks) {

                // 双深库位且浅库位有货，则需先对浅库位进行库位移转
//                if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
//                    String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
//                    TaskWrk hallowLocNoTask = taskWrkMapper.selectByStartPoint(shallowLocNo);
//                    if (!Cools.isEmpty(hallowLocNoTask)){
//                        continue;
//                    }
//                }
                // 堆垛机控制过滤
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                    continue;
                }

                // 已经存在吊车执行任务时，则过滤
                if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                    continue;
                }

                if (taskWrk == null || Cools.isEmpty(taskWrk.getTargetPoint()) || taskWrk.getTargetPoint().equals("") || taskWrk.getWrkNo() == null) {
                    continue;
                }
                // 工作档状态判断
                if (taskWrk.getIoType() != 3 || taskWrk.getTargetPoint() == null) {
                    log.error("查询工作档数据不符合条件--入出类型/目标库位号, 工作号={}，源库位={}，入出类型={}", taskWrk.getWrkNo(), taskWrk.getTargetPoint(), taskWrk.getIoType());
                    continue;
                }

                // 命令下发区 --------------------------------------------------------------------------


                // 1.堆垛机开始移动
@@ -409,7 +917,8 @@
                crnCommand.setDestinationPosX(Utils.getRowShort(taskWrk.getTargetPoint()));     // 目标库位排
                crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint()));     // 目标库位列
                crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint()));     // 目标库位层
                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
                crnCommand.setCommand((short) 1);
                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand), false)) {
                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改工作档状态 11.生成出库ID => 12.吊车出库中
@@ -419,7 +928,39 @@
                    if (taskWrkMapper.updateById(taskWrk) == 0) {
                        log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                    }
                    break;
                    String response = "";
                    Boolean bool=false;
                    HashMap<String, Object> headParam = new HashMap<>();
                    headParam.put("TaskNo", taskWrk.getTaskNo());
                    try {
                        response = new HttpHandler.Builder()
                                // .setHeaders(headParam)
                                .setUri(wmsUrl)
                                .setPath(taskStatusFeedbackPath)
                                .setJson(JSON.toJSONString(headParam))
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        if(jsonObject.get("ReturnStatus").equals(0)){
                            bool = true;
                            taskWrk.setStatus(2);
                            taskWrkMapper.updateById(taskWrk);
                        }

                    } catch (Exception e) {
                        log.error("wcs派发移库库任务上报wms失败", taskWrk);
//                        throw new CoolException("wcs派发移库库任务上报wms失败");
                    }finally {
                        apiLogService.save("wcs派发移库任务上报wms"
                                , wmsUrl + taskStatusFeedbackPath
                                , null
                                , "127.0.0.1"
                                , JSON.toJSONString(headParam)
                                , response
                                , bool
                        );
                    }

                }
                return;
            }
@@ -430,35 +971,121 @@
    /**
     * 执行对工作档的完成操作
     */
    @Async
    public void storeFinished() {
//    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 synchronized void storeFinished() throws InterruptedException {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }
            if (crnProtocol == null) {
                continue;
            }

            //  状态：等待确认 并且  任务完成位 = 1
            if (crnProtocol.getTaskFinish() == 1 && crnProtocol.getTaskNo() != 0) {
                // 获取入库待确认工作档
                TaskWrk taskWrk = taskWrkMapper.selectCrnNoWorking(crn.getId(),crnProtocol.getTaskNo().intValue());
                if (taskWrk == null) {
            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) && crnProtocol.getTaskNo() != 999) {
                    log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                    continue;
                }
                // 入库 + 库位转移  ==> 4.入库完成
                if (taskWrk.getWrkSts() == 3 || (taskWrk.getWrkSts() == 12 && taskWrk.getIoType() == 3)) {
                    taskWrk.setWrkSts(4);
                } else {
                    continue;
                //确认完成信号
                boolean result = crnOperaUtils.crnTaskComplete(crn.getId());
                Thread.sleep(1000);
                if(!result){
                    return;
                }
                Date now = new Date();
                taskWrk.setModiTime(now);
                Integer integerTaskWrk = taskWrkMapper.updateById(taskWrk);
                // 修改成功后复位堆垛机
                if (integerTaskWrk > 0) {
                    // 堆垛机复位
                    crnThread.setResetFlag(true);
                if (!Cools.isEmpty(taskWrk)) {
                    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.setModiUser(9999L);
                        locMastService.updateById(locMast);
                    } else if (taskWrk.getIoType() == 2 && taskWrk.getWrkSts() == 12) {
                        taskWrk.setWrkSts(13);//出库完成
                        taskWrk.setStatus(5);//完结

                        //更新库位状态
                        LocMast locMast = locMastService.selectByLocNo(taskWrk.getStartPoint());
                        locMast.setLocSts("O");//O.空库位
                        locMast.setBarcode("");//托盘码
                        locMast.setModiTime(new Date());
                        locMast.setModiUser(9999L);
                        locMastService.updateById(locMast);
                    } else if (taskWrk.getIoType() == 3 && taskWrk.getWrkSts() == 12) {
                        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.setModiUser(9999L);
                        locMastService.updateById(locMast);

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

            }
        }
    }
@@ -466,8 +1093,7 @@
    /**
     * 堆垛机异常信息记录
     */
    @Async
    public void recCrnErr(){
    public synchronized void recCrnErr() {
        Date now = new Date();
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
@@ -476,20 +1102,20 @@
            if (crnProtocol == null) {
                continue;
            }
            if (true) {
            if (false) {
//            if (crnProtocol.getModeType() != CrnModeType.STOP) {
                // 有任务
                if (crnProtocol.getTaskNo() != 0) {
                    BasErrLog latest = basErrLogService.findLatestByTaskNo(crn.getId(), crnProtocol.getTaskNo().intValue());
                    // 有异常
                    if (latest == null) {
                        if (crnProtocol.getAlarm1() != null && crnProtocol.getAlarm1() > 0) {
                        if (crnProtocol.getAlarm() != null && crnProtocol.getAlarm() > 0) {
                            WrkMast wrkMast = wrkMastMapper.selectById(crnProtocol.getTaskNo());
                            if (wrkMast == null) {
                                continue;
                            }
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm1());
                            String errName = crnError==null? String.valueOf(crnProtocol.getAlarm1()):crnError.getErrName();
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
                            String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName();
                            BasErrLog basErrLog = new BasErrLog(
                                    null,    // 编号
                                    wrkMast.getWrkNo(),    // 工作号
@@ -528,15 +1154,15 @@
                            }
                        }
                    }
                // 无任务
                    // 无任务
                } else {
                    BasErrLog latest = basErrLogService.findLatest(crn.getId());
                    // 有异常
                    if (crnProtocol.getAlarm1() != null && crnProtocol.getAlarm1() > 0) {
                    if (crnProtocol.getAlarm1() != null && crnProtocol.getAlarm() > 0) {
                        // 记录新异常
                        if (latest == null || (latest.getErrCode() != crnProtocol.getAlarm1().intValue())) {
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm1());
                            String errName = crnError==null? String.valueOf(crnProtocol.getAlarm1()):crnError.getErrName();
                        if (latest == null || (latest.getErrCode() != crnProtocol.getAlarm().intValue())) {
                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
                            String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName();
                            BasErrLog basErrLog = new BasErrLog(
                                    null,    // 编号
                                    null,    // 工作号
@@ -551,7 +1177,7 @@
                                    null,    // 源站
                                    null,    // 源库位
                                    null,    // 条码
                                    (int)crnProtocol.getAlarm1(),    // 异常码
                                    (int) crnProtocol.getAlarm1(),    // 异常码
                                    errName,    // 异常
                                    1,    // 异常情况
                                    now,    // 添加时间
@@ -564,7 +1190,7 @@
                                log.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
                            }
                        }
                    // 无异常
                        // 无异常
                    } else {
                        // 异常修复
                        if (latest != null && latest.getStatus() == 1) {
@@ -582,25 +1208,150 @@
        }
    }

    //自动派发任务
    public void autoDistribute() {
        Config config = configService.selectByCode("autoDistribute");
        if (config == null) {
            return;
        }
//    //自动派发任务
//    public synchronized 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());
//            }
//        }
//    }

        if (config.getValue().equals("false")) {//判断是否开启自动派发任务
            return;
        }
    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;//当前步序没有到达最后一条命令
            }

        for (TaskWrk taskWrk : taskWrkService.selectReceive()) {
            try {
                taskWrkService.distribute(taskWrk.getTaskNo(), 9527L);
            } catch (CoolException e) {
                e.printStackTrace();
            //判断末端命令是否执行完成
            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);
            }
        }
    }

    private TaskWrk createTask1(Result result, String barcode) {
        String locNo = Utils.getLocNo(result.getRow(), result.getFloor(), result.getColumn());
        LocMast locMast = locMastService.selectByLocNo(locNo);
        if (locMast == null) {
            throw new CoolException("库位不存在");
        }

        Date now = new Date();
        TaskWrk taskWrk = new TaskWrk();
        int workNo1 = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
        taskWrk.setTaskNo(result.getTaskNo());//任务号
        taskWrk.setWrkNo(workNo1);
        taskWrk.setStatus(TaskStatusType.RECEIVE.id);//任务状态：接收
        taskWrk.setCreateTime(now);
        taskWrk.setIoType(1);//任务类型
        taskWrk.setIoPri(13);//优先级
        taskWrk.setBarcode(barcode);//条码
        taskWrk.setCrnNo(locMast.getCrnNo());
        taskWrk.setTargetPoint(locNo);
        taskWrk.setStartPoint("116");
        if (result.getAlley().equals("1")) {
            taskWrk.setCrnNo(1);
        } else {
            taskWrk.setCrnNo(2);
        }
        if (taskWrk.getIoType() == 1) {
            taskWrk.setWrkSts(2);
            if (!Cools.isEmpty(taskWrk.getTargetPoint())) {
                taskWrk.setOriginTargetPoint(taskWrk.getTargetPoint());
            }
        }
        return taskWrk;
    }

    private TaskWrk createTask(GetWmsDto dto, String barcode) {
        String wcsLocNo = dto.getLocNo();
        if (Cools.isEmpty(wcsLocNo)) {
            return null;
        }
        Date now = new Date();
        TaskWrk taskWrk = new TaskWrk();
        int workNo1 = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
        taskWrk.setTaskNo(dto.getWrkNo());//任务号
        taskWrk.setWrkNo(workNo1);
        taskWrk.setStatus(TaskStatusType.RECEIVE.id);//任务状态：接收
        taskWrk.setCreateTime(now);
        taskWrk.setIoType(1);//任务类型
        taskWrk.setIoPri(Cools.isEmpty(dto.getTaskPriority()) ? 300 : Integer.parseInt(dto.getTaskPriority()));//优先级
        taskWrk.setBarcode(barcode);//条码
        LocMast locMast = locMastService.selectByLocNo(wcsLocNo);
        taskWrk.setCrnNo(locMast.getCrnNo());
        taskWrk.setTargetPoint(wcsLocNo);
        taskWrk.setStartPoint(dto.getStaNo().toString());
        if (taskWrk.getIoType() == 1) {
            taskWrk.setWrkSts(2);
            if (!Cools.isEmpty(taskWrk.getTargetPoint())) {
                taskWrk.setOriginTargetPoint(taskWrk.getTargetPoint());
            }

//        } else if (param.getIoType() == 2) {
//            taskWrk.setWrkSts(11);
//            if (!Cools.isEmpty(param.getStartPoint())) {
//                taskWrk.setStartPoint(Utils.getWcsLocNo(param.getStartPoint()));//起点
//                taskWrk.setOriginStartPoint(param.getStartPoint());
//            }
//            taskWrk.setTargetPoint(param.getTargetPoint());
//        }else if (param.getIoType() == 3){
//            taskWrk.setWrkSts(11);
//            if (!Cools.isEmpty(param.getStartPoint())) {
//                taskWrk.setStartPoint(param.getStartPoint());//起点
//                taskWrk.setOriginStartPoint(param.getStartPoint());
//            }
        }
        return taskWrk;
    }

}