配置信息

zhangc

2025-03-15 c4981fa8aa11b6509a5fb21f11ebe01c868a666a

配置信息

 src/main/java/com/zy/asrs/entity/param/Result.java

@@ -4,13 +4,18 @@

@Data
public class Result {
    private Long ShelfUnitId;   //分配的货位ID
    private String Alley;       //分配的货位所属巷道
    private Long TaskId;        //分配的货位所属任务ID
    private String TaskNo;      //分配的货位所属任务编号
    private int Row;            //分配的货位所属排
    private int Floor;          //分配的货位所属层
    private int Column;         //分配的货位所属列
    //站位编号   用户是从哪个口入的
    private Integer TerminalNo;
    /**
     * 分配的货位所属任务ID
     */
    private String taskNo;
    /**
     * 库位号
     */
    private String locNo;
    /**
     * 堆垛机编号
     */
    private Integer crnNo;


}

 src/main/java/com/zy/asrs/entity/param/StorageEscalationParam.java

@@ -5,7 +5,9 @@
@Data
public class StorageEscalationParam {
    //托盘码
    private String BoxNo;
    private String barcode;
    //站点码
    private Integer stationCode;
    //执行状态   0：成功 1：失败
    private Integer WCSStatus = 0;
    //错误信息   具体的错误信息（超高，超重等）

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

File was deleted

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

@@ -112,6 +112,15 @@
    @Autowired
    private SiteController siteController;

    @Value("${wms.code}")
    private String code;
    @Value("${wms.successCode}")
    private String successCode;
    @Value("${wms.msg}")
    private String msg;
    @Value("${wms.data}")
    private String data;


    public void generateStoreWrkFile1() throws IOException, InterruptedException {
        try {
@@ -120,6 +129,7 @@
                // 遍历入库口
                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    StorageEscalationParam storageEscalationParam = new StorageEscalationParam();
                    storageEscalationParam.setStationCode(inSta.getStaNo());
                    // 获取入库站信息
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
@@ -129,8 +139,6 @@
                        staProtocol = staProtocol.clone();
                    }
                    Short workNo = staProtocol.getWorkNo();
                    Short stano = staProtocol.getStaNo();

                    // 尺寸检测异常
                    boolean back = false;
                    String errMsg = "";
@@ -191,7 +199,7 @@
                            storageEscalationParam.setWCSErrorMessage(storageEscalationParam.getWCSErrorMessage() + errMsg);
                        }
                        log.info("组托入库={}", storageEscalationParam);
                        storageEscalationParam.setBoxNo(BoxNo);
                        storageEscalationParam.setBarcode(BoxNo);
                        String response = "";
                        Boolean success = false;
                        try {
@@ -207,12 +215,88 @@
                                devpThread.setPakMk(staProtocol.getSiteId(), false);
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            } else {
                                if (!Cools.isEmpty(response) && !Cools.isEmpty(jsonObject.get("ReturnStatus")) && jsonObject.get("ReturnStatus").equals(0) && !Cools.isEmpty(jsonObject.get("Result").toString())) {
                                    Result result = JSON.parseObject(jsonObject.get("Result").toString(), Result.class);
                                if (!Cools.isEmpty(response) && !Cools.isEmpty(jsonObject.get(code)) && jsonObject.get(code).equals(successCode)) {
                                    Result result = JSON.parseObject(jsonObject.get(data).toString(), Result.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", result.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", result.getLocNo()));
                                    if (Cools.isEmpty(locMast)) {
                                        try {
                                            HashMap<String, Object> headParam1 = new HashMap<>();
                                            headParam1.put("taskNo", result.getTaskNo());
                                            headParam1.put("status", 6);
                                            headParam1.put("ioType", 1);
                                            headParam1.put("barcode", BoxNo);
                                            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", result.getTaskNo());
                                            throw new CoolException("wcs派发入库任务上报wms失败,派发库位==》不为空《==，异常信息：" + e);
                                        }
                                    }


                                    // 创新一个入库工作档
                                    TaskWrk taskWrk = taskWrkService.selectByTaskNo(result.getTaskNo());
                                    if (Cools.isEmpty(taskWrk)) {
                                        taskWrk = createTask1(result, BoxNo);
                                        taskWrk = createInTask(result, BoxNo, inSta.getStaNo());
                                        if (Cools.isEmpty(taskWrk)) {
                                            log.error("库位异常，库位号：={}", taskWrk.getOriginTargetPoint());
                                        } else {
@@ -289,279 +373,6 @@
                        log.info("入库请求参数=" + JSON.toJSONString(BoxNo));
                        log.info("入库请求返回参数=" + JSON.toJSONString(response));
                    }
                }
            }
        } catch (Exception e) {
            log.error("generateStoreWrkFile e", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

    public 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) {
@@ -1463,10 +1274,10 @@
        return response;
    }

    private TaskWrk createTask1(Result result, String barcode) {
        String locNo = Utils.Fusion(result.getRow(), result.getFloor(), result.getColumn());
    private TaskWrk createInTask(Result result, String barcode, Integer startPoint) {
        //String locNo = Utils.Fusion(result.getRow(), result.getFloor(), result.getColumn());


        String locNo = result.getLocNo();
        Date now = new Date();
        TaskWrk taskWrk = new TaskWrk();
        int workNo1 = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
@@ -1480,12 +1291,9 @@
        LocMast locMast = locMastService.selectByLocNo(locNo);
        taskWrk.setCrnNo(locMast.getCrnNo());
        taskWrk.setTargetPoint(locNo);
        taskWrk.setStartPoint("116");
        if (result.getAlley().equals("1")) {
            taskWrk.setCrnNo(1);
        } else {
            taskWrk.setCrnNo(2);
        }
        taskWrk.setStartPoint(startPoint + "");
        taskWrk.setCrnNo(result.getCrnNo());

        if (taskWrk.getIoType() == 1) {
            taskWrk.setWrkSts(2);
            if (!Cools.isEmpty(taskWrk.getTargetPoint())) {
@@ -1495,47 +1303,6 @@
        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;
    }

    /**
     * 入出库模式切换函数
@@ -1545,18 +1312,15 @@
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                for (DevpSlave.Sta outSta : devp.getOutSta()) {
                    WrkMast pakout = wrkMastMapper.selectWorkingPakout(outSta.getStaNo());
                    switch (outSta.getStaNo()) {

                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    if (inSta.getStaNo() == 2) {
                        continue;
                    }
                    WrkMast pakout = wrkMastMapper.selectWorkingPakout(inSta.getStaNo());
                    switch (inSta.getStaNo()) {
                        case 203://1F
                        case 203:
                            if (pakout != null) {
                                if (devpThread.ioModeOf2F != IoModeType.PAKOUT_MODE) {
                                if (devpThread.ioModeOf1F1 != IoModeType.PAKOUT_MODE) {
                                    // 出库切换中
                                    devpThread.ioModeOf2F = IoModeType.PAKOUT_BOOTING;
                                    devpThread.ioModeOf1F1 = IoModeType.PAKOUT_BOOTING;
                                    WrkMast pakin = wrkMastMapper.selectWorkingPakin(inSta.getStaNo());
                                    if (pakin == null && !devpThread.getStation().get(inSta.getStaNo()).isLoading()
                                            && !devpThread.getStation().get(inSta.getStaNo() + 1).isLoading()
@@ -1570,7 +1334,7 @@
                                devpThread.ioModeOf2F = IoModeType.PAKIN_MODE;
                            }
                            break;
                        case 401://1F
                        case 401:
                            if (pakout != null) {
                                if (devpThread.ioModeOf4F != IoModeType.PAKOUT_MODE) {
                                    // 出库切换中

 src/main/java/com/zy/core/MainCpProcess.java

File was deleted

 src/main/java/com/zy/core/thread/SiemensDevpThread.java

@@ -79,8 +79,16 @@
     * 3.出库启动中 （不能生成入库工作档）
     * 4.出库模式
     */
    public IoModeType ioModeOf2F = IoModeType.NONE;
    public IoModeType ioModeOf4F = IoModeType.NONE;
    public IoModeType ioModeOf1F1 = IoModeType.NONE;
    public IoModeType ioModeOf1F2 = IoModeType.NONE;
    public IoModeType ioModeOf1F3 = IoModeType.NONE;
    public IoModeType ioModeOf1F4 = IoModeType.NONE;
    public IoModeType ioModeOf1F5 = IoModeType.NONE;

    public IoModeType ioModeOf2F1 = IoModeType.NONE;
    public IoModeType ioModeOf2F2 = IoModeType.NONE;
    public IoModeType ioModeOf2F3 = IoModeType.NONE;

    private DevpSlave slave;
    private SiemensS7Net siemensS7Net;
    private Map<Integer, StaProtocol> station = new ConcurrentHashMap<>();

 src/main/resources/application-prod.yml

@@ -11,20 +11,67 @@
    offset: 2  #偏移量，当堆垛机站点列号=1时，偏移量=2
    port: 102
    crnOutStn[0]: #堆垛机出库站点
      staNo: 125
      staNo: 103
      row: 3
      bay: 1
      lev: 2
      devpPlcId: ${wcs-slave.devp[0].id}
    crnOutStn[1]: #堆垛机出库站点
      staNo: 106
      row: 3
      bay: 1
      lev: 2
      devpPlcId: ${wcs-slave.devp[0].id}
    crnInStn[0]: #堆垛机入库站点1
      staNo: 100
      staNo: 102
      row: 2
      bay: 1
      lev: 2
      backSta: 102
      backSta: 101
      devpPlcId: ${wcs-slave.devp[0].id}
    crnInStn[1]: #堆垛机入库站点1
      staNo: 105
      row: 2
      bay: 1
      lev: 2
      backSta: 104
      devpPlcId: ${wcs-slave.devp[0].id}
  crn[1]: #堆垛机2
    id: 2
    ip: 10.10.10.120
    slot: 0
    demo: false
    rack: 0
    offset: 2  #偏移量，当堆垛机站点列号=1时，偏移量=2
    port: 102
    crnOutStn[0]: #堆垛机出库站点
      staNo: 109
      row: 7
      bay: 1
      lev: 2
      devpPlcId: ${wcs-slave.devp[0].id}
    crnOutStn[1]: #堆垛机出库站点
      staNo: 112
      row: 7
      bay: 1
      lev: 2
      devpPlcId: ${wcs-slave.devp[0].id}
    crnInStn[0]: #堆垛机入库站点1
      staNo: 108
      row: 6
      bay: 1
      lev: 2
      backSta: 107
      devpPlcId: ${wcs-slave.devp[0].id}
    crnInStn[1]: #堆垛机入库站点1
      staNo: 111
      row: 6
      bay: 1
      lev: 2
      backSta: 110
      devpPlcId: ${wcs-slave.devp[0].id}
  crn[2]: #堆垛机2
    id: 3
    ip: 10.10.10.120
    slot: 0
    demo: false
@@ -37,12 +84,51 @@
      bay: 1
      lev: 2
      devpPlcId: ${wcs-slave.devp[0].id}
    crnOutStn[1]: #堆垛机出库站点
      staNo: 201
      row: 7
      bay: 1
      lev: 2
      devpPlcId: ${wcs-slave.devp[0].id}
    crnOutStn[2]: #堆垛机出库站点
      staNo: 205
      row: 7
      bay: 1
      lev: 2
      devpPlcId: ${wcs-slave.devp[0].id}
    crnOutStn[3]: #堆垛机出库站点
      staNo: 210
      row: 7
      bay: 1
      lev: 2
      devpPlcId: ${wcs-slave.devp[0].id}
    crnInStn[0]: #堆垛机入库站点1
      staNo: 120
      staNo: 114
      row: 6
      bay: 1
      lev: 2
      backSta: 106
      backSta: 113
      devpPlcId: ${wcs-slave.devp[0].id}
    crnInStn[1]: #堆垛机入库站点1
      staNo: 202
      row: 6
      bay: 1
      lev: 2
      backSta: 203
      devpPlcId: ${wcs-slave.devp[0].id}
    crnInStn[2]: #堆垛机入库站点1
      staNo: 206
      row: 6
      bay: 1
      lev: 2
      backSta: 207
      devpPlcId: ${wcs-slave.devp[0].id}
    crnInStn[3]: #堆垛机入库站点1
      staNo: 211
      row: 6
      bay: 1
      lev: 2
      backSta: 212
      devpPlcId: ${wcs-slave.devp[0].id}
  devp[0]: #输送线
    id: 1
@@ -54,209 +140,93 @@
      staNo: 116
    inSta[0]: #入库口1
      staNo: 116
      backSta: 110
      backSta: 101
      barcode: ${wcs-slave.barcode[0].id}
    inSta[1]: #入库口2
      staNo: 117
      backSta: 104
      barcode: ${wcs-slave.barcode[1].id}
    inSta[2]: #入库口3
      staNo: 118
      backSta: 107
      barcode: ${wcs-slave.barcode[2].id}
    inSta[3]: #入库口4
      staNo: 119
      backSta: 110
      barcode: ${wcs-slave.barcode[3].id}
    inSta[4]: #入库口1
      staNo: 120
      backSta: 113
      barcode: ${wcs-slave.barcode[4].id}
    inSta[5]: #入库口2
      staNo: 203
      backSta: 110
      barcode: ${wcs-slave.barcode[5].id}
    inSta[6]: #入库口3
      staNo: 207
      backSta: 110
      barcode: ${wcs-slave.barcode[6].id}
    inSta[7]: #入库口4
      staNo: 212
      backSta: 110
      barcode: ${wcs-slave.barcode[7].id}
    outSta[0]: #出库口1
      staNo: 105
      staNo: 116
    outSta[1]: #出库口2
      staNo: 107
    outSta[2]: #出库口2
      staNo: 109
    outSta[3]: #出库口1
      staNo: 110
  barcode[0]: #条码扫描仪
    port: 51236
    ip: 172.17.91.39
    id: 1
      staNo: 117
    outSta[2]: #出库口3
      staNo: 118
    outSta[3]: #出库口4
      staNo: 119
    outSta[4]: #出库口5
      staNo: 120
    outSta[5]: #出库口6
      staNo: 203
    outSta[6]: #出库口7
      staNo: 207
    outSta[7]: #出库口8
      staNo: 212


wcs-slave-product:
  doubleDeep: false #双深
  doubleLocs: 1,4,5,8 #双深库位排号 1,4,5,8
  groupCount: 4 #一个堆垛机负责的货架排数
  crn[0]: #堆垛机1
    id: 1
    ip: 10.10.10.110
    slot: 0
    demo: false
    rack: 0
    offset: 2  #偏移量，当堆垛机站点列号=1时，偏移量=2
    port: 102
    crnOutStn[0]: #堆垛机出库站点
      staNo: 125
      row: 3
      bay: 1
      lev: 2
      devpPlcId: ${wcs-slave.devp[0].id}
    crnInStn[0]: #堆垛机入库站点1
      staNo: 100
      row: 2
      bay: 1
      lev: 2
      backSta: 102
      devpPlcId: ${wcs-slave.devp[0].id}
  devp[0]: #输送线
    id: 1
  devp[1]: #输送线
    id: 2
    ip: 10.10.10.140
    rack: 0
    port: 102
    slot: 0
    emptyInSta[0]: #空板入库口0
      staNo: 116
    inSta[0]: #入库口1
      staNo: 116
      backSta: 110
      barcode: ${wcs-slave.barcode[0].id}
    outSta[0]: #出库口1
      staNo: 105
    outSta[1]: #出库口2
      staNo: 107
    outSta[2]: #出库口2
      staNo: 109
    outSta[3]: #出库口1
      staNo: 110
  barcode[0]: #条码扫描仪
    port: 51236
    ip: 172.17.91.39
    id: 1
#  crn[0]: #堆垛机1
#    rack: 0
#    offset: 2    #偏移量，当堆垛机站点列号=1时，偏移量=2
#    port: 102
#    crnOutStn[0]:    #堆垛机出库站点
#      staNo: 101
#      row: 2
#      bay: 1
#      lev: 1
#      devpPlcId: ${wcs-slave.devp[0].id}
#    ip: 192.168.1.100
#    crnInStn[0]:    #堆垛机入库站点1
#      staNo: 100
#      row: 1
#      bay: 1
#      lev: 1
#      devpPlcId: ${wcs-slave.devp[0].id}
#    id: 1
#    slot: 0
#    demo: false
#  crn[1]: #堆垛机2
#    rack: 0
#    offset: 2    #偏移量，当堆垛机站点列号=1时，偏移量=2
#    port: 102
#    crnOutStn[0]:    #堆垛机出库站点
#      staNo: 103
#      row: 5
#      bay: 1
#      lev: 1
#      devpPlcId: ${wcs-slave.devp[0].id}
#    ip: 192.168.1.110
#    crnInStn[0]:    #堆垛机入库站点1
#      staNo: 102
#      row: 4
#      bay: 1
#      lev: 1
#      devpPlcId: ${wcs-slave.devp[0].id}
#    id: 2
#    slot: 0
#    demo: false
#  barcode[3]: #条码扫描仪4
#    port: 51236
#    ip: 10.10.10.52
#    id: 4
#  barcode[2]: #条码扫描仪3
#    port: 51236
#    ip: 10.10.10.52
#    id: 3
#
#  barcode[1]: #条码扫描仪2
#    port: 51236
#    ip: 10.10.10.52
#    id: 2
#
#  devp[0]: #输送线
#    emptyInSta[2]: #空板入库口3
#      staNo: 104
#    emptyInSta[1]: #空板入库口2
#      staNo: 102
#    rack: 0
#    emptyInSta[0]: #空板入库口1
#      staNo: 100
#    ip: 192.168.1.140
#    outSta[4]: #出库口5
#      staNo: 104
#    outSta[3]: #出库口4
#      staNo: 103
#    outSta[6]: #出库口7
#      staNo: 106
#    slot: 0
#    outSta[5]: #出库口6
#      staNo: 105
#    outSta[0]: #出库口1
#      staNo: 100
#    outSta[2]: #出库口3
#      staNo: 102
#    emptyInSta[3]: #空板入库口4
#      staNo: 106
#    outSta[1]: #出库口2
#      staNo: 101
#    inSta[2]:
#      staNo: 104
#      barcode: ${wcs-slave.barcode[2].id}
#    inSta[3]:
#      staNo: 106
#      barcode: ${wcs-slave.barcode[3].id}
#    port: 102
#    outSta[7]: #出库口8
#      staNo: 107
#    inSta[0]: #入库口1
#      staNo: 100
#      barcode: ${wcs-slave.barcode[0].id}
#    inSta[1]: #入库口2
#      staNo: 102
#      barcode: ${wcs-slave.barcode[1].id}
#    id: 1
#
#
#  crn[2]: #堆垛机3
#    rack: 0
#    offset: 2    #偏移量，当堆垛机站点列号=1时，偏移量=2
#    port: 102
#    crnOutStn[0]:    #堆垛机出库站点
#      staNo: 105
#      row: 9
#      bay: 1
#      lev: 1
#      devpPlcId: ${wcs-slave.devp[0].id}
#    ip: 192.168.1.120
#    crnInStn[0]:    #堆垛机入库站点1
#      staNo: 104
#      row: 8
#      bay: 1
#      lev: 1
#      devpPlcId: ${wcs-slave.devp[0].id}
#    id: 3
#    slot: 0
#    demo: false
#  crn[3]: #堆垛机4
#    rack: 0
#    offset: 2    #偏移量，当堆垛机站点列号=1时，偏移量=2
#    port: 102
#    crnOutStn[0]:    #堆垛机出库站点
#      staNo: 107
#      row: 12
#      bay: 1
#      lev: 1
#      devpPlcId: ${wcs-slave.devp[0].id}
#    ip: 192.168.1.130
#    crnInStn[0]:    #堆垛机入库站点1
#      staNo: 106
#      row: 11
#      bay: 1
#      lev: 1
#      devpPlcId: ${wcs-slave.devp[0].id}
#    id: 4
#    slot: 0
#    demo: false
  barcode[1]: #条码扫描仪
    port: 51236
    ip: 172.17.91.39
    id: 2
  barcode[2]: #条码扫描仪
    port: 51236
    ip: 172.17.91.39
    id: 3
  barcode[3]: #条码扫描仪
    port: 51236
    ip: 172.17.91.39
    id: 4
  barcode[4]: #条码扫描仪
    port: 51236
    ip: 172.17.91.39
    id: 5
  barcode[5]: #条码扫描仪
    port: 51236
    ip: 172.17.91.39
    id: 6
  barcode[6]: #条码扫描仪
    port: 51236
    ip: 172.17.91.39
    id: 7
  barcode[7]: #条码扫描仪
    port: 51236
    ip: 172.17.91.39
    id: 8






 src/main/resources/application.yml

@@ -61,3 +61,7 @@
  TaskExecCallback: api/StereoscopicCallBack/TaskExecFinishedCallback
  # 移库申请接口
  movePath: api/InterFace/get_InterFace_TestStorage
  code: code
  successCode: 200
  msg: msg
  data: data