From a402a173ebbaa5851f2b76be9f6102c054a2832b Mon Sep 17 00:00:00 2001
From: zhangc <zc@123>
Date: 星期六, 15 三月 2025 17:00:03 +0800
Subject: [PATCH] 配置信息

---
 /dev/null                                                    | 1545 --------------------------------------------
 src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java  |  415 +----------
 src/main/java/com/zy/asrs/service/impl/ToWmsServiceImpl.java |   90 --
 src/main/java/com/zy/core/thread/SiemensDevpThread.java      |   16 
 src/main/java/com/zy/core/ServerBootstrap.java               |    5 
 5 files changed, 48 insertions(+), 2,023 deletions(-)

diff --git a/src/main/java/com/zy/asrs/service/impl/CommonServiceImpl.java b/src/main/java/com/zy/asrs/service/impl/CommonServiceImpl.java
deleted file mode 100644
index bdb42f5..0000000
--- a/src/main/java/com/zy/asrs/service/impl/CommonServiceImpl.java
+++ /dev/null
@@ -1,1545 +0,0 @@
-package com.zy.asrs.service.impl;
-
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONObject;
-import com.baomidou.mybatisplus.mapper.EntityWrapper;
-import com.core.common.Cools;
-import com.core.common.R;
-import com.core.exception.CoolException;
-import com.zy.asrs.controller.CrnController;
-import com.zy.asrs.controller.SiteController;
-import com.zy.asrs.domain.enums.TaskStatusType;
-import com.zy.asrs.domain.enums.WorkNoType;
-import com.zy.asrs.domain.param.CrnOperatorParam;
-import com.zy.asrs.entity.*;
-import com.zy.asrs.entity.wms.WmsResult;
-import com.zy.asrs.entity.wms.StorageEscalationParam;
-import com.zy.asrs.entity.param.TaskOverToWms;
-import com.zy.asrs.mapper.BasCrnErrorMapper;
-import com.zy.asrs.mapper.StaDescMapper;
-import com.zy.asrs.mapper.TaskWrkMapper;
-import com.zy.asrs.mapper.WrkMastMapper;
-import com.zy.asrs.service.*;
-import com.zy.asrs.utils.CommandUtils;
-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.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.transaction.interceptor.TransactionAspectSupport;
-
-import java.io.IOException;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 绔嬩綋浠撳簱WCS绯荤粺涓绘祦绋嬩笟鍔�
- * Created by vincent on 2020/8/6
- */
-@Slf4j
-@Service("commonService")
-@Transactional
-public class CommonServiceImpl {
-
-    public static final long COMMAND_TIMEOUT = 5 * 1000;
-
-    @Autowired
-    private SlaveProperties slaveProperties;
-    @Autowired
-    private WrkMastMapper wrkMastMapper;
-    @Autowired
-    private LocMastService locMastService;
-    @Autowired
-    private BasCrnpService basCrnpService;
-    @Autowired
-    private BasDevpService basDevpService;
-    @Autowired
-    private BasErrLogService basErrLogService;
-    @Autowired
-    private BasCrnErrorMapper basCrnErrorMapper;
-    @Autowired
-    private TaskWrkMapper taskWrkMapper;
-    @Autowired
-    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;
-
-    @Value("${wms.url}")
-    private String wmsUrl;
-    @Value("${wms.inboundTaskApplyPath}")
-    private String inboundTaskApplyPath;
-    @Value("${wms.TaskExecCallback}")
-    private String TaskExecCallback;
-    @Value("${wms.taskStatusFeedbackPath}")
-    private String taskStatusFeedbackPath;
-    @Autowired
-    private CrnController crnController;
-    @Autowired
-    private SiteController siteController;
-
-    public StorageEscalationParam getErrorMsg(StaProtocol staProtocol) {
-        StorageEscalationParam storageEscalationParam = new StorageEscalationParam();
-        if (staProtocol.isFrontErr()) {
-            storageEscalationParam.setWCSErrorMessage("鍓嶈秴闄�");
-            storageEscalationParam.setWCSStatus(1);
-        }
-        if (staProtocol.isBackErr()) {
-            storageEscalationParam.setWCSErrorMessage(storageEscalationParam.getWCSErrorMessage() + "鍚庤秴闄�");
-            storageEscalationParam.setWCSStatus(1);
-        }
-        if (staProtocol.isHighErr()) {
-            storageEscalationParam.setWCSErrorMessage(storageEscalationParam.getWCSErrorMessage() + "楂樿秴闄�");
-            storageEscalationParam.setWCSStatus(1);
-        }
-        if (staProtocol.isLeftErr()) {
-            storageEscalationParam.setWCSErrorMessage(storageEscalationParam.getWCSErrorMessage() + "宸﹁秴闄�");
-            storageEscalationParam.setWCSStatus(1);
-        }
-        if (staProtocol.isRightErr()) {
-            storageEscalationParam.setWCSErrorMessage(storageEscalationParam.getWCSErrorMessage() + "鍙宠秴闄�");
-            storageEscalationParam.setWCSStatus(1);
-        }
-        if (staProtocol.isWeightErr()) {
-            storageEscalationParam.setWCSErrorMessage(storageEscalationParam.getWCSErrorMessage() + "瓒呴噸");
-            storageEscalationParam.setWCSStatus(1);
-        }
-        if (staProtocol.isBarcodeErr()) {
-            storageEscalationParam.setWCSErrorMessage(storageEscalationParam.getWCSErrorMessage() + "鎵爜澶辫触");
-            storageEscalationParam.setWCSStatus(1);
-        }
-        return storageEscalationParam;
-    }
-
-    public void generateStoreWrkFile1() throws IOException, InterruptedException {
-        try {
-            // 鏍规嵁杈撻�佺嚎plc閬嶅巻
-            for (DevpSlave devp : slaveProperties.getDevp()) {
-                // 閬嶅巻鍏ュ簱鍙�
-                for (DevpSlave.Sta inSta : devp.getInSta()) {
-                    StorageEscalationParam storageEscalationParam = new StorageEscalationParam();
-                    // 鑾峰彇鍏ュ簱绔欎俊鎭�
-                    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.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 BoxNo = barcodeThread.getBarcode();
-                        TaskWrk taskWrk1 = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", BoxNo));
-                        if (!Cools.isEmpty(taskWrk1)) {
-                            log.info("鎵樼洏鐮侊細" + BoxNo + "浠诲姟妗e瓨鍦�");
-                            if (taskWrk1.getIoType() == 1 && taskWrk1.getStartPoint().equals(staProtocol.getSiteId().toString())) {
-                                StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
-                                        .eq("crn_no", taskWrk1.getCrnNo()).eq("type_no", 1).eq("stn_no", staProtocol.getSiteId()));
-                                if (Cools.isEmpty(staDesc)) {
-                                    return;
-                                } else {
-                                    continue;
-                                }
-                            }
-                        }
-                        if (back) {
-                            storageEscalationParam.setWCSStatus(1);
-                            storageEscalationParam.setWCSErrorMessage(storageEscalationParam.getWCSErrorMessage() + errMsg);
-                        }
-                        log.info("缁勬墭鍏ュ簱={}", storageEscalationParam);
-                        storageEscalationParam.setBoxNo(BoxNo);
-                        String response = "";
-                        Boolean success = false;
-                        try {
-                            response = new HttpHandler.Builder()
-                                    .setUri(wmsUrl)
-                                    .setPath(inboundTaskApplyPath)
-                                    .setJson(JSON.toJSONString(storageEscalationParam))
-                                    .build()
-                                    .doPost();
-                            JSONObject jsonObject = JSON.parseObject(response);
-                            if (back) {
-                                staProtocol.setStaNo(inSta.getBackSta().shortValue());
-                                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())) {
-                                    WmsResult result = JSON.parseObject(jsonObject.get("Result").toString(), WmsResult.class);
-                                    // 鍒涙柊涓�涓叆搴撳伐浣滄。
-                                    TaskWrk taskWrk = taskWrkService.selectByTaskNo(result.getTaskNo());
-                                    if (Cools.isEmpty(taskWrk)) {
-                                        taskWrk = createTask1(result, BoxNo);
-                                        if (Cools.isEmpty(taskWrk)) {
-                                            log.error("搴撲綅寮傚父锛屽簱浣嶅彿锛�={}", taskWrk.getOriginTargetPoint());
-                                        } 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));
-                                            HashMap<String, Object> hashMap = new HashMap<>();
-                                            hashMap.put("TaskNo", taskWrk.getTaskNo());
-                                            try {
-                                                //寮�濮嬩笂鎶�,浠诲姟寮�濮嬫椂锛學CS鍥炶皟WMS
-                                                response = new HttpHandler.Builder()
-                                                        .setUri(wmsUrl)
-                                                        .setPath(taskStatusFeedbackPath)
-                                                        .setJson(JSON.toJSONString(hashMap))
-                                                        .build()
-                                                        .doPost();
-                                                JSONObject jsonObject1 = JSON.parseObject(response);
-                                                Boolean bool = false;
-                                                if (jsonObject1.get("ReturnStatus").equals(0)) {
-                                                    bool = true;
-                                                }
-                                                apiLogService.save("wcs寮�濮嬪叆搴撲换鍔′笂鎶ms"
-                                                        , wmsUrl + TaskExecCallback
-                                                        , null
-                                                        , "127.0.0.1"
-                                                        , JSON.toJSONString(hashMap)
-                                                        , response
-                                                        , bool
-                                                );
-                                            } catch (Exception e) {
-
-                                            }
-                                        }
-                                    } else {
-                                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
-                                        devpThread.setPakMk(staProtocol.getSiteId(), false);
-                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
-                                    }
-
-                                } else {
-                                    staProtocol.setStaNo(inSta.getBackSta().shortValue());
-                                    devpThread.setPakMk(staProtocol.getSiteId(), false);
-                                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
-                                }
-                            }
-                        } 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(storageEscalationParam)
-                                    , response
-                                    , success
-                            );
-                        }
-                        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 + "浠诲姟妗e瓨鍦�");
-                                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 + "浠诲姟妗e瓨鍦�");
-                                        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();
-        }
-    }
-
-
-    /**
-     * 鍫嗗灈鏈虹珯鍑哄簱鍒板嚭搴撶珯
-     */
-    public void crnStnToOutStn() {
-        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
-            // 閬嶅巻鍫嗗灈鏈哄嚭搴撶珯
-            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
-                List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnSlave.getId()).eq("crn_stn", crnStn.getStaNo()));
-                for (StaDesc staDesc : staDescs) {
-                    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 (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == 0)) {
-                            // 鏌ヨ宸ヤ綔妗�
-                            TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), staDesc.getStnNo().toString());
-                            if (taskWrk == null) {
-                                continue;
-                            }
-                            log.info("涓嬪彂杈撻�佺嚎浠诲姟锛歵askWrk:" + 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("涓嬪彂杈撻�佺嚎浠诲姟鎴愬姛锛歵askWrk:" + JSON.toJSONString(taskWrk));
-                                taskWrk.setStatus(5);
-                                taskWrk.setWrkSts(14);
-                                taskWrkService.updateById(taskWrk);
-
-                            } else {
-                                log.error("涓嬪彂杈撻�佺嚎浠诲姟澶辫触锛歵askWrk:" + JSON.toJSONString(taskWrk));
-//                                log.error("涓嬪彂杈撻�佺嚎浠诲姟澶辫触锛氬紓甯镐俊鎭�:"+JSON.toJSONString(r));
-                            }
-                        }
-                    } catch (Exception e) {
-                        log.error("鍑哄簱鍒板嚭搴撶珯寮傚父:寮傚父淇℃伅锛�" + e);
-                    }
-                }
-
-            }
-        }
-    }
-
-    /**
-     * 鍏ュ嚭搴�  ===>>  鍫嗗灈鏈哄叆鍑哄簱浣滀笟涓嬪彂
-     */
-    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;
-            }
-            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
-                    && crnProtocol.getLoaded() == 0 && crnProtocol.getForkPos() == 0) {
-                // 濡傛灉鏈�杩戜竴娆℃槸鍏ュ簱妯″紡
-                if (crnProtocol.getLastIo().equals("I")) {
-                    if (basCrnp.getInEnable().equals("Y")) {
-                        this.crnStnToLoc(crn, crnProtocol); //  鍏ュ簱
-                        crnProtocol.setLastIo("O");
-                    } else if (basCrnp.getOutEnable().equals("Y")) {
-                        this.locToCrnStn(crn, crnProtocol); //  鍑哄簱
-                        crnProtocol.setLastIo("I");
-                    }
-                }
-                // 濡傛灉鏈�杩戜竴娆℃槸鍑哄簱妯″紡
-                else if (crnProtocol.getLastIo().equals("O")) {
-                    if (basCrnp.getOutEnable().equals("Y")) {
-                        this.locToCrnStn(crn, crnProtocol); //  鍑哄簱
-                        crnProtocol.setLastIo("I");
-                    } else if (basCrnp.getInEnable().equals("Y")) {
-                        this.crnStnToLoc(crn, crnProtocol); //  鍏ュ簱
-                        crnProtocol.setLastIo("O");
-                    }
-                }
-
-                // 搴撲綅绉昏浆
-                this.locToLoc(crn, crnProtocol);
-            }
-
-        }
-    }
-
-    /**
-     * 鍏ュ簱  ===>>  鍫嗗灈鏈虹珯鍒板簱浣�
-     */
-    public void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol) throws IOException {
-        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
-            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("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) {
-                    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(), staDesc.getStnNo().toString());
-                if (null == taskWrk) {
-                    continue;
-                }
-
-                // 鍫嗗灈鏈烘帶鍒惰繃婊�
-                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
-                    continue;
-                }
-
-                // 宸茬粡瀛樺湪鍚婅溅鎵ц浠诲姟鏃讹紝鍒欒繃婊�
-                if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
-                    continue;
-                }
-
-//                int workNo = commonService.getWorkNo(WorkNoType.PAKIN.type);//鑾峰彇鍏ュ簱宸ヤ綔鍙�
-//                taskWrk.setWrkNo(workNo);//宸ヤ綔鍙�
-                taskWrk.setStatus(TaskStatusType.DISTRIBUTE.id);//娲惧彂鐘舵��
-                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) {
-                        log.error("淇敼宸ヤ綔妗g姸鎬� 2.璁惧涓婅蛋 => 3.鍚婅溅鍏ュ簱涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", taskWrk.getWrkNo());
-                        log.error("淇敼宸ヤ綔妗g姸鎬� 2.璁惧涓婅蛋 => 3.鍚婅溅鍏ュ簱涓� 澶辫触锛侊紒锛屽紓甯革細" + e);
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * 鍑哄簱  ===>>  搴撲綅鍒板爢鍨涙満绔�
-     * 2022-06-09 TQS淇敼锛屾煡璇㈠伐浣滄。LIST锛岄亶鍘嗕笅鍙戯紝闃叉绗竴涓换鍔″牭濉炲嚭搴�
-     */
-    public void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol) {
-        List<TaskWrk> taskWrksInitial = taskWrkMapper.selectPakOut(slave.getId(), null);
-        if (taskWrksInitial.size() == 0) {
-            return;
-        }
-        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
-            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
-            for (StaDesc staDesc : staDescs) {
-                // 鑾峰彇宸ヤ綔鐘舵�佷负11锛堢敓鎴愬嚭搴揑D锛夌殑鍑哄簱宸ヤ綔妗�
-                List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(slave.getId(), staDesc.getStnNo().toString());
-                for (TaskWrk taskWrk : taskWrks) {
-                    if (taskWrk == null) {
-                        continue;
-                    }
-                    // 宸ヤ綔妗g姸鎬佸垽鏂�
-                    if (taskWrk.getIoType() != 2 || taskWrk.getTargetPoint() == null || taskWrk.getStartPoint() == null) {
-                        log.error("鏌ヨ宸ヤ綔妗f暟鎹笉绗﹀悎鏉′欢--鍏ュ嚭绫诲瀷/绔欑偣, 宸ヤ綔鍙�={}锛屾簮搴撲綅={}锛屽叆鍑虹被鍨�={}", 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;
-                        }
-
-                        // 宸茬粡瀛樺湪鍚婅溅鎵ц浠诲姟鏃讹紝鍒欒繃婊�
-                        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 (Cools.isEmpty(taskWrk.getMarkStart()) || taskWrk.getMarkStart() == 0) {
-                            HashMap<String, Object> hashMap = new HashMap<>();
-                            hashMap.put("TaskNo", taskWrk.getTaskNo());
-                            String response = "";
-                            try {
-                                //寮�濮嬩笂鎶�,鍑哄簱浠诲姟寮�濮嬫椂锛學CS鍥炶皟WMS
-                                response = new HttpHandler.Builder()
-                                        .setUri(wmsUrl)
-                                        .setPath(taskStatusFeedbackPath)
-                                        .setJson(JSON.toJSONString(hashMap))
-                                        .build()
-                                        .doPost();
-                                JSONObject jsonObject = JSON.parseObject(response);
-                                Boolean bool = false;
-                                if (jsonObject.get("ReturnStatus").equals(0)) {
-                                    bool = true;
-                                    taskWrk.setMarkStart(1);
-                                }
-                                apiLogService.save("wcs寮�濮嬩换鍔′笂鎶ms"
-                                        , wmsUrl + TaskExecCallback
-                                        , null
-                                        , "127.0.0.1"
-                                        , JSON.toJSONString(hashMap)
-                                        , response
-                                        , bool
-                                );
-                            } catch (Exception e) {
-                            }
-                        }
-
-                        if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, command), false)) {
-                            log.error("鍫嗗灈鏈哄懡浠ょ敓鎴愬け璐ワ紝鍫嗗灈鏈哄彿={}锛屼换鍔℃暟鎹�={}", taskWrk.getCrnNo(), JSON.toJSON(command));
-                            throw new CoolException("鍫嗗灈鏈哄懡浠ょ敓鎴愬け璐�");
-                        } else {
-                            try {
-                                // 淇敼宸ヤ綔妗g姸鎬� 11.鐢熸垚鍑哄簱ID => 12.鍚婅溅鍑哄簱涓�
-                                Date now = new Date();
-                                taskWrk.setWrkSts(12);
-                                taskWrk.setStatus(2);
-                                taskWrk.setModiTime(now);
-                                if (taskWrkMapper.updateById(taskWrk) == 0) {
-                                    log.error("淇敼宸ヤ綔妗g姸鎬� 11.鐢熸垚鍑哄簱ID => 12.鍚婅溅鍑哄簱涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", taskWrk.getWrkNo());
-                                }
-                            } catch (Exception e) {
-                                log.error("淇敼宸ヤ綔妗g姸鎬� 11.鐢熸垚鍑哄簱ID => 12.鍚婅溅鍑哄簱涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", taskWrk.getWrkNo());
-                                log.error("淇敼宸ヤ綔妗g姸鎬� 11.鐢熸垚鍑哄簱ID => 12.鍚婅溅鍑哄簱涓� 澶辫触锛侊紒锛屽紓甯革細" + e);
-                            }
-//                            try {
-//                                HashMap<String, Object> headParam = new HashMap<>();
-//                                headParam.put("taskNo", taskWrk.getTaskNo());
-//                                headParam.put("status", taskWrk.getStatus());
-//                                headParam.put("ioType", taskWrk.getIoType());
-//                                headParam.put("barcode", taskWrk.getBarcode());
-//                                String response;
-//                                response = new HttpHandler.Builder()
-//                                        // .setHeaders(headParam)
-//                                        .setUri(wmsUrl)
-//                                        .setPath(taskStatusFeedbackPath)
-//                                        .setJson(JSON.toJSONString(headParam))
-//                                        .build()
-//                                        .doPost();
-//                                JSONObject jsonObject = JSON.parseObject(response);
-//                                apiLogService.save("wcs娲惧彂鍑哄簱浠诲姟涓婃姤wms"
-//                                        , wmsUrl + taskStatusFeedbackPath
-//                                        , null
-//                                        , "127.0.0.1"
-//                                        , JSON.toJSONString(headParam)
-//                                        , response
-//                                        , true
-//                                );
-//                            } catch (Exception e) {
-//                                log.error("wcs娲惧彂鍑哄簱浠诲姟涓婃姤wms澶辫触", JSON.toJSONString(taskWrk));
-////                                throw new CoolException("wcs娲惧彂鍏ュ簱浠诲姟涓婃姤wms澶辫触");
-//                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * 搴撲綅绉昏浆
-     */
-    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol) {
-        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
-            // 鑾峰彇宸ヤ綔鐘舵�佷负11锛堢敓鎴愬嚭搴揑D锛夌殑绉诲簱宸ヤ綔妗�
-            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;
-                }
-                // 宸ヤ綔妗g姸鎬佸垽鏂�
-                if (taskWrk.getIoType() != 3 || taskWrk.getTargetPoint() == null) {
-                    log.error("鏌ヨ宸ヤ綔妗f暟鎹笉绗﹀悎鏉′欢--鍏ュ嚭绫诲瀷/鐩爣搴撲綅鍙�, 宸ヤ綔鍙�={}锛屾簮搴撲綅={}锛屽叆鍑虹被鍨�={}", taskWrk.getWrkNo(), taskWrk.getTargetPoint(), taskWrk.getIoType());
-                    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(Utils.getRowShort(taskWrk.getTargetPoint()));     // 鐩爣搴撲綅鎺�
-                crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint()));     // 鐩爣搴撲綅鍒�
-                crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint()));     // 鐩爣搴撲綅灞�
-                crnCommand.setCommand((short) 1);
-                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand), false)) {
-                    log.error("鍫嗗灈鏈哄懡浠や笅鍙戝け璐ワ紝鍫嗗灈鏈哄彿={}锛屼换鍔℃暟鎹�={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
-                } else {
-                    // 淇敼宸ヤ綔妗g姸鎬� 11.鐢熸垚鍑哄簱ID => 12.鍚婅溅鍑哄簱涓�
-                    Date now = new Date();
-                    taskWrk.setWrkSts(12);
-                    taskWrk.setStatus(2);
-                    taskWrk.setModiTime(now);
-                    if (taskWrkMapper.updateById(taskWrk) == 0) {
-                        log.error("淇敼宸ヤ綔妗g姸鎬� 11.鐢熸垚鍑哄簱ID => 12.鍚婅溅鍑哄簱涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", taskWrk.getWrkNo());
-                    }
-                    try {
-                        HashMap<String, Object> headParam = new HashMap<>();
-                        headParam.put("TaskNo", taskWrk.getTaskNo());
-                        String response;
-                        response = new HttpHandler.Builder()
-                                // .setHeaders(headParam)
-                                .setUri(wmsUrl)
-                                .setPath(taskStatusFeedbackPath)
-                                .setJson(JSON.toJSONString(headParam))
-                                .build()
-                                .doPost();
-                        JSONObject jsonObject = JSON.parseObject(response);
-                        apiLogService.save("wcs娲惧彂绉诲簱浠诲姟涓婃姤wms"
-                                , wmsUrl + taskStatusFeedbackPath
-                                , null
-                                , "127.0.0.1"
-                                , JSON.toJSONString(headParam)
-                                , response
-                                , true
-                        );
-                    } catch (Exception e) {
-                        log.error("wcs娲惧彂绉诲簱搴撲换鍔′笂鎶ms澶辫触", taskWrk);
-//                        throw new CoolException("wcs娲惧彂绉诲簱搴撲换鍔′笂鎶ms澶辫触");
-                    }
-
-                }
-                return;
-            }
-        }
-
-    }
-
-    /**
-     * 鎵ц瀵瑰伐浣滄。鐨勫畬鎴愭搷浣�
-     */
-//    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("鍫嗗灈鏈哄浜庣瓑寰呯‘璁や笖浠诲姟瀹屾垚鐘舵�侊紝浣嗘湭鎵惧埌宸ヤ綔妗c�傚爢鍨涙満鍙�={}锛屽伐浣滃彿={}", crn.getId(), crnProtocol.getTaskNo());
-//                    continue;
-//                }
-//
-//                //鑾峰彇鎸囦护ID
-//                Integer commandId = crnProtocol.getCommandId();
-//                CommandInfo commandInfo = new CommandInfo();
-//                if (Cools.isEmpty(commandId)){
-//                    commandInfo = commandInfoService.selectOne(new EntityWrapper<CommandInfo>()
-//                            .eq("wrk_no",crnProtocol.getTaskNo())
-//                            .eq("device","Crn"));
-//                }else {
-//                    commandInfo = commandInfoService.selectById(commandId);
-//                }
-//
-//
-//                if (commandInfo == null) {
-//                    //鎸囦护涓嶅瓨鍦�
-//                    continue;
-//                }
-//                if (commandInfo.getCommandStatus() == 3){
-//                    continue;
-//                }
-//                commandInfo.setCommandStatus(CommandStatusType.COMPLETE.id);//鎸囦护瀹屾垚
-//                commandInfo.setCompleteTime(new Date());//鎸囦护瀹屾垚鏃堕棿
-//                if (commandInfoService.updateById(commandInfo)) {//淇敼鎴愬姛鍚庡浣嶅爢鍨涙満
-//                    // 鍫嗗灈鏈哄浣�
-//                    crnThread.setResetFlag(true);
-//                }
-//            }
-//        }
-//    }
-
-    /**
-     * 鎵ц瀵瑰伐浣滄。鐨勫畬鎴愭搷浣�
-     */
-    public void storeFinished() throws InterruptedException {
-        for (CrnSlave crn : slaveProperties.getCrn()) {
-            // 鑾峰彇鍫嗗灈鏈轰俊鎭�
-            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) && crnProtocol.getTaskNo() != 999) {
-                    log.error("鍫嗗灈鏈哄浜庣瓑寰呯‘璁や笖浠诲姟瀹屾垚鐘舵�侊紝浣嗘湭鎵惧埌宸ヤ綔妗c�傚爢鍨涙満鍙�={}锛屽伐浣滃彿={}", crn.getId(), crnProtocol.getTaskNo());
-                    continue;
-                }
-                //纭瀹屾垚淇″彿
-                CrnOperatorParam crnOperatorParam = new CrnOperatorParam();
-                crnOperatorParam.setCrnNo(crn.getId());
-                R r = crnController.crnTaskComplete(crnOperatorParam);
-                Thread.sleep(1000);
-                if (!r.get("code").equals(200)) {
-                    return;
-                }
-                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);
-                }
-
-            }
-        }
-    }
-
-    /**
-     * 鍫嗗灈鏈哄紓甯镐俊鎭褰�
-     */
-    public void recCrnErr() {
-        Date now = new Date();
-        for (CrnSlave crn : slaveProperties.getCrn()) {
-            // 鑾峰彇鍫嗗灈鏈轰俊鎭�
-            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
-            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
-            if (crnProtocol == null) {
-                continue;
-            }
-            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.getAlarm() != null && crnProtocol.getAlarm() > 0) {
-                            WrkMast wrkMast = wrkMastMapper.selectById(crnProtocol.getTaskNo());
-                            if (wrkMast == null) {
-                                continue;
-                            }
-                            BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
-                            String errName = crnError == null ? String.valueOf(crnProtocol.getAlarm()) : crnError.getErrName();
-                            BasErrLog basErrLog = new BasErrLog(
-                                    null,    // 缂栧彿
-                                    wrkMast.getWrkNo(),    // 宸ヤ綔鍙�
-                                    now,    // 鍙戠敓鏃堕棿
-                                    null,    // 缁撴潫鏃堕棿
-                                    wrkMast.getWrkSts(),    // 宸ヤ綔鐘舵��
-                                    wrkMast.getIoType(),    // 鍏ュ嚭搴撶被鍨�
-                                    crn.getId(),    // 鍫嗗灈鏈�
-                                    null,    // plc
-                                    wrkMast.getLocNo(),    // 鐩爣搴撲綅
-                                    wrkMast.getStaNo(),    // 鐩爣绔�
-                                    wrkMast.getSourceStaNo(),    // 婧愮珯
-                                    wrkMast.getSourceLocNo(),    // 婧愬簱浣�
-                                    wrkMast.getBarcode(),    // 鏉$爜
-                                    (int) crnProtocol.getAlarm1(),    // 寮傚父鐮�
-                                    errName,    // 寮傚父
-                                    1,    // 寮傚父鎯呭喌
-                                    now,    // 娣诲姞鏃堕棿
-                                    null,    // 娣诲姞浜哄憳
-                                    now,    // 淇敼鏃堕棿
-                                    null,    // 淇敼浜哄憳
-                                    "浠诲姟涓紓甯�"    // 澶囨敞
-                            );
-                            if (!basErrLogService.insert(basErrLog)) {
-                                log.error("鍫嗗灈鏈簆lc寮傚父璁板綍澶辫触 ===>> [id:{}] [error:{}]", crn.getId(), errName);
-                            }
-                        }
-                    } else {
-                        // 寮傚父淇
-                        if (crnProtocol.getAlarm1() == null || crnProtocol.getAlarm1() == 0) {
-                            latest.setEndTime(now);
-                            latest.setUpdateTime(now);
-                            latest.setStatus(2);
-                            if (!basErrLogService.updateById(latest)) {
-                                log.error("鍫嗗灈鏈簆lc寮傚父璁板綍淇澶辫触 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
-                            }
-                        }
-                    }
-                    // 鏃犱换鍔�
-                } else {
-                    BasErrLog latest = basErrLogService.findLatest(crn.getId());
-                    // 鏈夊紓甯�
-                    if (crnProtocol.getAlarm1() != null && crnProtocol.getAlarm() > 0) {
-                        // 璁板綍鏂板紓甯�
-                        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,    // 宸ヤ綔鍙�
-                                    now,    // 鍙戠敓鏃堕棿
-                                    null,    // 缁撴潫鏃堕棿
-                                    null,    // 宸ヤ綔鐘舵��
-                                    null,    // 鍏ュ嚭搴撶被鍨�
-                                    crn.getId(),    // 鍫嗗灈鏈�
-                                    null,    // plc
-                                    null,    // 鐩爣搴撲綅
-                                    null,    // 鐩爣绔�
-                                    null,    // 婧愮珯
-                                    null,    // 婧愬簱浣�
-                                    null,    // 鏉$爜
-                                    (int) crnProtocol.getAlarm1(),    // 寮傚父鐮�
-                                    errName,    // 寮傚父
-                                    1,    // 寮傚父鎯呭喌
-                                    now,    // 娣诲姞鏃堕棿
-                                    null,    // 娣诲姞浜哄憳
-                                    now,    // 淇敼鏃堕棿
-                                    null,    // 淇敼浜哄憳
-                                    "鏃犱换鍔″紓甯�"    // 澶囨敞
-                            );
-                            if (!basErrLogService.insert(basErrLog)) {
-                                log.error("鍫嗗灈鏈簆lc寮傚父璁板綍澶辫触 ===>> [id:{}] [error:{}]", crn.getId(), errName);
-                            }
-                        }
-                        // 鏃犲紓甯�
-                    } else {
-                        // 寮傚父淇
-                        if (latest != null && latest.getStatus() == 1) {
-                            latest.setEndTime(now);
-                            latest.setUpdateTime(now);
-                            latest.setStatus(2);
-                            if (!basErrLogService.updateById(latest)) {
-                                log.error("鍫嗗灈鏈簆lc寮傚父璁板綍淇澶辫触 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
-                            }
-                        }
-                    }
-                }
-            }
-
-        }
-    }
-
-    //鑷姩娲惧彂浠诲姟
-    public void autoDistribute() {
-        Config config = configService.selectByCode("autoDistribute");
-        if (config == null) {
-            return;
-        }
-
-        if (config.getValue().equals("false")) {//鍒ゆ柇鏄惁寮�鍚嚜鍔ㄦ淳鍙戜换鍔�
-            return;
-        }
-
-        for (TaskWrk taskWrk : taskWrkService.selectReceive()) {
-
-            try {
-                taskWrkService.distribute(taskWrk.getTaskNo(), 9527L);
-            } catch (CoolException e) {
-                log.info(e.getMessage());
-            }
-        }
-    }
-
-    //agv鍙栨斁璐т换鍔″畬鎴�
-    public synchronized void autoCompleteAGV() {
-        List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<>());
-        try {
-            Thread.sleep(500);
-        } catch (Exception e) {
-
-        }
-
-        for (BasDevp basDevp : basDevps) {
-            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
-            StaProtocol staProtocol = devpThread.getStation().get(basDevp.getDevNo());
-            if (staProtocol == null) {
-                continue;
-            } else {
-                staProtocol = staProtocol.clone();
-            }
-            if (basDevp.getWrkNo() != 0) {
-                if (basDevp.getAgvTargetPick() != 0) {//鍙栬揣
-                    staProtocol.setAgvTypeSign((short) 0);
-                    staProtocol.setStaNo(basDevp.getDevNo().shortValue());
-                    MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
-                }
-                boolean sign = true;
-                if (basDevp.getAgvTargetPlace() != 0) {
-                    sign = false;
-                    basDevp.setAgvTargetPlace(0);
-                    basDevpService.updateById(basDevp);
-                    staProtocol.setAgvTypeSign((short) 3);//1
-                    staProtocol.setStaNo(basDevp.getDevNo().shortValue());
-                    MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
-                }
-            } else {
-                if (basDevp.getAgvTargetPlace() != 0) {
-                    if (basDevp.getLoading().equals("Y")) {
-                        staProtocol.setAgvTypeSign((short) 1);
-                        staProtocol.setStaNo(basDevp.getDevNo().shortValue());
-                        MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
-                    } else {
-                        log.error("AGV鏀捐揣瀹屾垚浣嗚緭閫佺嚎鏃犵墿锛屽浣嶄俊鍙� ===>> [staNo:{}] [basDevp:{}]", basDevp.getDevNo(), basDevp);
-                        basDevp.setAgvTargetPlace(0);
-                        basDevpService.updateById(basDevp);
-                        staProtocol.setAgvTypeSign((short) 3);//1
-                        staProtocol.setStaNo(basDevp.getDevNo().shortValue());
-                        MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
-                    }
-
-                }
-                if (basDevp.getAgvTargetPick() != 0) {
-                    basDevp.setAgvTargetPick(0);
-                    basDevpService.updateById(basDevp);
-                    staProtocol.setAgvTypeSign((short) 2);//0
-                    staProtocol.setStaNo(basDevp.getDevNo().shortValue());
-                    MessageQueue.offer(SlaveType.Devp, 1, new Task(4, staProtocol));
-                }
-            }
-        }
-    }
-
-    public synchronized void autoCompleteTask() {
-        List<TaskWrk> taskWrks = taskWrkMapper.selectWorkingTask();
-        for (TaskWrk taskWrk : taskWrks) {
-            //鑾峰彇鍛戒护闆嗗悎
-            List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
-            if (taskWrk.getCommandStep() < commandInfos.size()) {
-                continue;//褰撳墠姝ュ簭娌℃湁鍒拌揪鏈�鍚庝竴鏉″懡浠�
-            }
-
-            //鍒ゆ柇鏈鍛戒护鏄惁鎵ц瀹屾垚
-            CommandInfo commandInfo = commandInfos.get(commandInfos.size() - 1);
-            if (commandInfo.getCommandStatus() != CommandStatusType.COMPLETE.id) {
-                continue;//鎸囦护鏈畬鎴�
-            }
-
-            Date now = new Date();
-            //鎸囦护宸插畬鎴愶紝鏇存柊浠诲姟
-            if (taskWrk.getIoType() == 1) {
-                //鍏ュ簱浠诲姟
-                taskWrk.setWrkSts(4);//3.鍚婅溅鍏ュ簱涓� => 4.鍏ュ簱瀹屾垚
-                //taskWrk.setStatus(TaskStatusType.COMPLETE.id);
-                taskWrk.setModiTime(now);
-                taskWrkService.updateById(taskWrk);
-
-                //鏇存柊搴撲綅鐘舵��
-                LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
-                locMast.setLocSts("F");//F.鍦ㄥ簱
-                locMast.setBarcode(taskWrk.getBarcode());//鎵樼洏鐮�
-                locMast.setModiTime(now);
-                locMast.setModiUser(9999L);
-                locMastService.updateById(locMast);
-            } else if (taskWrk.getIoType() == 2) {
-                //鍑哄簱浠诲姟
-                taskWrk.setWrkSts(14);//12.鍚婅溅鍑哄簱涓� => 14.鍑哄簱瀹屾垚
-//                taskWrk.setStatus(TaskStatusType.COMPLETE.id);
-                taskWrk.setModiTime(now);
-                taskWrkService.updateById(taskWrk);
-
-                //鏇存柊搴撲綅鐘舵��
-                LocMast locMast = locMastService.selectByLocNo(taskWrk.getStartPoint());
-                locMast.setLocSts("O");//O.绌哄簱浣�
-                locMast.setBarcode("");//鎵樼洏鐮�
-                locMast.setModiTime(now);
-                locMast.setModiUser(9999L);
-                locMastService.updateById(locMast);
-            }
-        }
-    }
-
-
-    public synchronized String CrnStartRunning(TaskWrk taskWrk) {
-        String tasktype = null;
-        switch (taskWrk.getIoType()) {
-            case 1:
-                tasktype = "RK";
-                break;
-            case 2:
-                tasktype = "CK";
-                break;
-            case 3:
-                tasktype = "YK";
-                break;
-            default:
-                tasktype = "鏈煡";
-        }
-        Map<String, Object> map = new HashMap<>();
-        map.put("x-api-key", "7a15b5db-29b6-552c-8cff-0cfec3756da2");
-        TaskOverToWms taskOverToWms = new TaskOverToWms();
-        taskOverToWms.setFeedbackFrom("WCS"); //鏉ユ簮
-        taskOverToWms.setWarehouseId("1688469798893297665"); //浠撳簱鏍囪瘑
-        taskOverToWms.setTaskNo(taskWrk.getTaskNo()); //浠诲姟鍙�
-        taskOverToWms.setTaskType(tasktype); // 浠诲姟绫诲瀷
-        taskOverToWms.setContainerCode(taskWrk.getBarcode()); // 瀹瑰櫒缂栫爜
-        if (taskWrk.getIoType() == 1 || taskWrk.getIoType() == 3) {
-            taskOverToWms.setEquipmentCode(String.valueOf(taskWrk.getCrnNo())); //璁惧缂栫爜
-            taskOverToWms.setTargetLocationCode(taskWrk.getOriginTargetPoint()); //鐩爣搴撲綅
-        } else if (taskWrk.getIoType() == 2) {
-            Map<Integer, String> map1 = new HashMap<>();
-            map1.put(102, "J-1101");
-            map1.put(106, "J-1103");
-            map1.put(110, "J-1105");
-            map1.put(114, "J-1107");
-            map1.put(118, "J-1109");
-            map1.put(122, "J-1111");
-            map1.put(305, "H-1101");
-            map1.put(405, "G-1101");
-            taskOverToWms.setEquipmentCode(map1.get(taskWrk.getTargetPoint())); //璁惧缂栫爜
-            taskOverToWms.setSourceLocationCode(taskWrk.getOriginStartPoint()); //婧愬簱浣�
-        }
-
-        taskOverToWms.setTaskStatus("executing"); //浠诲姟鐘舵��
-        String response = null;
-        try {
-            response = new HttpHandler.Builder()
-                    .setHeaders(map)
-                    .setUri(wmsUrl)
-                    .setPath("wcsManager/wcsInterface/taskStatusFeedback")
-                    .setJson(JSON.toJSONString(taskOverToWms))
-                    .build()
-                    .doPost();
-        } catch (Exception e) {
-            log.error("鍫嗗灈鏈轰换鍔″畬鎴愶紝璇锋眰wms浠诲姟瀹屾垚鎺ュ彛澶辫触");
-        }
-        apiLogService.save("鍫嗗灈鏈哄紑濮嬭繍琛�"
-                , wmsUrl + "wcsManager/wcsInterface/taskStatusFeedback"
-                , null
-                , "127.0.0.1"
-                , JSON.toJSONString(taskOverToWms)
-                , response
-                , true
-        );
-        return response;
-    }
-
-    private TaskWrk createTask1(WmsResult result, String barcode) {
-        String locNo = Utils.Fusion(result.getRow(), result.getFloor(), result.getColumn());
-
-
-        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.DISTRIBUTE.id);//浠诲姟鐘舵�侊細娲惧彂
-        taskWrk.setCreateTime(now);
-        taskWrk.setIoType(1);//浠诲姟绫诲瀷
-        taskWrk.setIoPri(13);//浼樺厛绾�
-        taskWrk.setBarcode(barcode);//鏉$爜
-        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);
-        }
-        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;
-    }
-
-}
diff --git a/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java b/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
index 20dd5f3..8c4b9f1 100644
--- a/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
+++ b/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
@@ -1,7 +1,6 @@
 package com.zy.asrs.service.impl;
 
 import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
 import com.core.common.Cools;
 import com.core.common.R;
@@ -11,7 +10,6 @@
 import com.zy.asrs.domain.enums.WorkNoType;
 import com.zy.asrs.domain.param.CrnOperatorParam;
 import com.zy.asrs.entity.*;
-import com.zy.asrs.entity.param.TaskOverToWms;
 import com.zy.asrs.entity.wms.StorageEscalationParam;
 import com.zy.asrs.entity.wms.WmsResult;
 import com.zy.asrs.mapper.BasCrnErrorMapper;
@@ -22,7 +20,6 @@
 import com.zy.asrs.utils.CommandUtils;
 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;
@@ -37,20 +34,16 @@
 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.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.interceptor.TransactionAspectSupport;
 
 import java.io.IOException;
 import java.util.Date;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 /**
  * 绔嬩綋浠撳簱WCS绯荤粺涓绘祦绋嬩笟鍔�
@@ -81,51 +74,27 @@
     private TaskWrkMapper taskWrkMapper;
     @Autowired
     private TaskWrkService taskWrkService;
-    @Autowired
-    private ConfigService configService;
+
     @Autowired
     private StaDescMapper staDescMapper;
-    @Autowired
-    private CommandInfoService commandInfoService;
+
 
     @Autowired
     private StaDescService staDescService;
 
-    @Autowired
-    private ApiLogService apiLogService;
+
     @Autowired
     private CommonService commonService;
 
     @Autowired
     private ToWmsService toWmsService;
 
-    @Value("${wms.url}")
-    private String wmsUrl;
-
-    @Value("${wms.inboundTaskApplyPath}")
-    private String inboundTaskApplyPath;
-
-    @Value("${wms.taskExecCallback}")
-    private String taskExecCallback;
-
-    @Value("${wms.taskStatusFeedbackPath}")
-    private String taskStatusFeedbackPath;
 
     @Autowired
     private CrnController crnController;
 
-    @Value("${wms.code}")
-    private String code;
-
-    @Value("${wms.successCode}")
-    private String successCode;
-
-    @Value("${wms.msg}")
-    private String msg;
-
-    @Value("${wms.data}")
-    private String data;
-
+    @Autowired
+    private ConfigService configService;
 
     public void generateStoreWrkFile1() throws IOException, InterruptedException {
         try {
@@ -205,98 +174,41 @@
                         }
                         log.info("缁勬墭鍏ュ簱={}", storageEscalationParam);
                         storageEscalationParam.setBarcode(BoxNo);
-                        String response = "";
-                        Boolean success = false;
-                        try {
-                            WmsResult result = toWmsService.getLocNoFromWms(storageEscalationParam);
-                            if (back) {
-                                staProtocol.setStaNo(inSta.getBackSta().shortValue());
-                                devpThread.setPakMk(staProtocol.getSiteId(), false);
-                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
-                            } else {
-                                if (result != null) {
 
-
-
-                                    // 鍒涙柊涓�涓叆搴撳伐浣滄。
-                                    TaskWrk taskWrk = taskWrkService.selectByTaskNo(result.getTaskNo());
-                                    if (Cools.isEmpty(taskWrk)) {
-                                        taskWrk = createInTask(result, BoxNo, inSta.getStaNo());
-                                        if (Cools.isEmpty(taskWrk)) {
-                                            log.error("搴撲綅寮傚父锛屽簱浣嶅彿锛�={}", taskWrk.getOriginTargetPoint());
-                                        } 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));
-                                            HashMap<String, Object> hashMap = new HashMap<>();
-                                            hashMap.put("TaskNo", taskWrk.getTaskNo());
-                                            try {
-                                                //寮�濮嬩笂鎶�,浠诲姟寮�濮嬫椂锛學CS鍥炶皟WMS
-                                                response = new HttpHandler.Builder()
-                                                        .setUri(wmsUrl)
-                                                        .setPath(taskStatusFeedbackPath)
-                                                        .setJson(JSON.toJSONString(hashMap))
-                                                        .build()
-                                                        .doPost();
-                                                JSONObject jsonObject1 = JSON.parseObject(response);
-                                                Boolean bool = false;
-                                                if (jsonObject1.get("ReturnStatus").equals(0)) {
-                                                    bool = true;
-                                                }
-                                                apiLogService.save("wcs寮�濮嬪叆搴撲换鍔′笂鎶ms"
-                                                        , wmsUrl + taskExecCallback
-                                                        , null
-                                                        , "127.0.0.1"
-                                                        , JSON.toJSONString(hashMap)
-                                                        , response
-                                                        , bool
-                                                );
-                                            } catch (Exception e) {
-
-                                            }
-                                        }
-                                    } else {
-                                        staProtocol.setStaNo(inSta.getBackSta().shortValue());
-                                        devpThread.setPakMk(staProtocol.getSiteId(), false);
-                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
-                                    }
-
+                        WmsResult result = toWmsService.getLocNoFromWms(storageEscalationParam);
+                        if (back) {
+                            log.info("鎵樼洏閫�鍥�==>{}锛寋}", BoxNo, errMsg);
+                            staProtocol.setStaNo(inSta.getBackSta().shortValue());
+                            devpThread.setPakMk(staProtocol.getSiteId(), false);
+                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
+                        } else {
+                            if (result != null) {
+                                // 鍒涙柊涓�涓叆搴撳伐浣滄。
+                                TaskWrk taskWrk = taskWrkService.selectByTaskNo(result.getTaskNo());
+                                if (Cools.isEmpty(taskWrk)) {
+                                    taskWrk = createInTask(result, BoxNo, inSta.getStaNo());
+                                    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));
+                                    //娣诲姞涓婃姤鏃ュ織
+                                    toWmsService.addReportLog(taskWrk);
                                 } else {
+                                    log.info("鍒涘缓宸ヤ綔妗eけ璐�==>{}", taskWrk.getTaskNo());
                                     staProtocol.setStaNo(inSta.getBackSta().shortValue());
                                     devpThread.setPakMk(staProtocol.getSiteId(), false);
                                     MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                 }
+                            } else {
+                                log.info("璇锋眰wms鑾峰彇搴撲綅澶辫触==>{}", BoxNo);
+                                staProtocol.setStaNo(inSta.getBackSta().shortValue());
+                                devpThread.setPakMk(staProtocol.getSiteId(), false);
+                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                             }
-                        } 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(storageEscalationParam)
-                                    , response
-                                    , success
-                            );
                         }
-                        log.info("鍏ュ簱璇锋眰鍙傛暟=" + JSON.toJSONString(BoxNo));
-                        log.info("鍏ュ簱璇锋眰杩斿洖鍙傛暟=" + JSON.toJSONString(response));
+                        log.info("鍏ュ簱璇锋眰杩斿洖鍙傛暟=" + JSON.toJSONString(result));
                     }
                 }
             }
@@ -400,7 +312,6 @@
                         crnProtocol.setLastIo("O");
                     }
                 }
-
                 // 搴撲綅绉昏浆
                 this.locToLoc(crn, crnProtocol);
             }
@@ -580,33 +491,8 @@
                         command.setCommand((short) 1);
 
                         if (Cools.isEmpty(taskWrk.getMarkStart()) || taskWrk.getMarkStart() == 0) {
-                            HashMap<String, Object> hashMap = new HashMap<>();
-                            hashMap.put("TaskNo", taskWrk.getTaskNo());
-                            String response = "";
-                            try {
-                                //寮�濮嬩笂鎶�,鍑哄簱浠诲姟寮�濮嬫椂锛學CS鍥炶皟WMS
-                                response = new HttpHandler.Builder()
-                                        .setUri(wmsUrl)
-                                        .setPath(taskStatusFeedbackPath)
-                                        .setJson(JSON.toJSONString(hashMap))
-                                        .build()
-                                        .doPost();
-                                JSONObject jsonObject = JSON.parseObject(response);
-                                Boolean bool = false;
-                                if (jsonObject.get(code).equals(0)) {
-                                    bool = true;
-                                    taskWrk.setMarkStart(1);
-                                }
-                                apiLogService.save("wcs寮�濮嬩换鍔′笂鎶ms"
-                                        , wmsUrl + TaskExecCallback
-                                        , null
-                                        , "127.0.0.1"
-                                        , JSON.toJSONString(hashMap)
-                                        , response
-                                        , bool
-                                );
-                            } catch (Exception e) {
-                            }
+                            toWmsService.addReportLog(taskWrk);
+                            taskWrk.setMarkStart(1);
                         }
 
                         if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, command), false)) {
@@ -626,33 +512,6 @@
                                 log.error("淇敼宸ヤ綔妗g姸鎬� 11.鐢熸垚鍑哄簱ID => 12.鍚婅溅鍑哄簱涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", taskWrk.getWrkNo());
                                 log.error("淇敼宸ヤ綔妗g姸鎬� 11.鐢熸垚鍑哄簱ID => 12.鍚婅溅鍑哄簱涓� 澶辫触锛侊紒锛屽紓甯革細" + e);
                             }
-//                            try {
-//                                HashMap<String, Object> headParam = new HashMap<>();
-//                                headParam.put("taskNo", taskWrk.getTaskNo());
-//                                headParam.put("status", taskWrk.getStatus());
-//                                headParam.put("ioType", taskWrk.getIoType());
-//                                headParam.put("barcode", taskWrk.getBarcode());
-//                                String response;
-//                                response = new HttpHandler.Builder()
-//                                        // .setHeaders(headParam)
-//                                        .setUri(wmsUrl)
-//                                        .setPath(taskStatusFeedbackPath)
-//                                        .setJson(JSON.toJSONString(headParam))
-//                                        .build()
-//                                        .doPost();
-//                                JSONObject jsonObject = JSON.parseObject(response);
-//                                apiLogService.save("wcs娲惧彂鍑哄簱浠诲姟涓婃姤wms"
-//                                        , wmsUrl + taskStatusFeedbackPath
-//                                        , null
-//                                        , "127.0.0.1"
-//                                        , JSON.toJSONString(headParam)
-//                                        , response
-//                                        , true
-//                                );
-//                            } catch (Exception e) {
-//                                log.error("wcs娲惧彂鍑哄簱浠诲姟涓婃姤wms澶辫触", JSON.toJSONString(taskWrk));
-////                                throw new CoolException("wcs娲惧彂鍏ュ簱浠诲姟涓婃姤wms澶辫触");
-//                            }
                         }
                     }
                 }
@@ -720,31 +579,7 @@
                     if (taskWrkMapper.updateById(taskWrk) == 0) {
                         log.error("淇敼宸ヤ綔妗g姸鎬� 11.鐢熸垚鍑哄簱ID => 12.鍚婅溅鍑哄簱涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", taskWrk.getWrkNo());
                     }
-                    try {
-                        HashMap<String, Object> headParam = new HashMap<>();
-                        headParam.put("taskNo", taskWrk.getTaskNo());
-                        String response;
-                        response = new HttpHandler.Builder()
-                                // .setHeaders(headParam)
-                                .setUri(wmsUrl)
-                                .setPath(taskStatusFeedbackPath)
-                                .setJson(JSON.toJSONString(headParam))
-                                .build()
-                                .doPost();
-                        JSONObject jsonObject = JSON.parseObject(response);
-                        apiLogService.save("wcs娲惧彂绉诲簱浠诲姟涓婃姤wms"
-                                , wmsUrl + taskStatusFeedbackPath
-                                , null
-                                , "127.0.0.1"
-                                , JSON.toJSONString(headParam)
-                                , response
-                                , true
-                        );
-                    } catch (Exception e) {
-                        log.error("wcs娲惧彂绉诲簱搴撲换鍔′笂鎶ms澶辫触", taskWrk);
-//                        throw new CoolException("wcs娲惧彂绉诲簱搴撲换鍔′笂鎶ms澶辫触");
-                    }
-
+                    toWmsService.addReportLog(taskWrk);
                 }
                 return;
             }
@@ -752,53 +587,6 @@
 
     }
 
-    /**
-     * 鎵ц瀵瑰伐浣滄。鐨勫畬鎴愭搷浣�
-     */
-//    public void storeFinished() {
-//        for (CrnSlave crn : slaveProperties.getCrn()) {
-//            // 鑾峰彇鍫嗗灈鏈轰俊鎭�
-//            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
-//            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
-//            if (crnProtocol == null) { continue; }
-//
-//            //  鐘舵�侊細绛夊緟纭 骞朵笖  浠诲姟瀹屾垚浣� = 1
-//            if (crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.getTaskNo() != 0) {
-//                //鑾峰彇鍏ュ簱寰呯‘璁ゅ伐浣滄。
-//                TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crn.getId(),crnProtocol.getTaskNo().intValue());
-//                if (Cools.isEmpty(taskWrk)) {
-////                    log.error("鍫嗗灈鏈哄浜庣瓑寰呯‘璁や笖浠诲姟瀹屾垚鐘舵�侊紝浣嗘湭鎵惧埌宸ヤ綔妗c�傚爢鍨涙満鍙�={}锛屽伐浣滃彿={}", 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);
-//                }
-//            }
-//        }
-//    }
 
     /**
      * 鎵ц瀵瑰伐浣滄。鐨勫畬鎴愭搷浣�
@@ -992,26 +780,6 @@
         }
     }
 
-    //鑷姩娲惧彂浠诲姟
-    public void autoDistribute() {
-        Config config = configService.selectByCode("autoDistribute");
-        if (config == null) {
-            return;
-        }
-
-        if (config.getValue().equals("false")) {//鍒ゆ柇鏄惁寮�鍚嚜鍔ㄦ淳鍙戜换鍔�
-            return;
-        }
-
-        for (TaskWrk taskWrk : taskWrkService.selectReceive()) {
-
-            try {
-                taskWrkService.distribute(taskWrk.getTaskNo(), 9527L);
-            } catch (CoolException e) {
-                log.info(e.getMessage());
-            }
-        }
-    }
 
     //agv鍙栨斁璐т换鍔″畬鎴�
     public synchronized void autoCompleteAGV() {
@@ -1072,119 +840,6 @@
         }
     }
 
-    public synchronized void autoCompleteTask() {
-        List<TaskWrk> taskWrks = taskWrkMapper.selectWorkingTask();
-        for (TaskWrk taskWrk : taskWrks) {
-            //鑾峰彇鍛戒护闆嗗悎
-            List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
-            if (taskWrk.getCommandStep() < commandInfos.size()) {
-                continue;//褰撳墠姝ュ簭娌℃湁鍒拌揪鏈�鍚庝竴鏉″懡浠�
-            }
-
-            //鍒ゆ柇鏈鍛戒护鏄惁鎵ц瀹屾垚
-            CommandInfo commandInfo = commandInfos.get(commandInfos.size() - 1);
-            if (commandInfo.getCommandStatus() != CommandStatusType.COMPLETE.id) {
-                continue;//鎸囦护鏈畬鎴�
-            }
-
-            Date now = new Date();
-            //鎸囦护宸插畬鎴愶紝鏇存柊浠诲姟
-            if (taskWrk.getIoType() == 1) {
-                //鍏ュ簱浠诲姟
-                taskWrk.setWrkSts(4);//3.鍚婅溅鍏ュ簱涓� => 4.鍏ュ簱瀹屾垚
-                //taskWrk.setStatus(TaskStatusType.COMPLETE.id);
-                taskWrk.setModiTime(now);
-                taskWrkService.updateById(taskWrk);
-
-                //鏇存柊搴撲綅鐘舵��
-                LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
-                locMast.setLocSts("F");//F.鍦ㄥ簱
-                locMast.setBarcode(taskWrk.getBarcode());//鎵樼洏鐮�
-                locMast.setModiTime(now);
-                locMast.setModiUser(9999L);
-                locMastService.updateById(locMast);
-            } else if (taskWrk.getIoType() == 2) {
-                //鍑哄簱浠诲姟
-                taskWrk.setWrkSts(14);//12.鍚婅溅鍑哄簱涓� => 14.鍑哄簱瀹屾垚
-//                taskWrk.setStatus(TaskStatusType.COMPLETE.id);
-                taskWrk.setModiTime(now);
-                taskWrkService.updateById(taskWrk);
-
-                //鏇存柊搴撲綅鐘舵��
-                LocMast locMast = locMastService.selectByLocNo(taskWrk.getStartPoint());
-                locMast.setLocSts("O");//O.绌哄簱浣�
-                locMast.setBarcode("");//鎵樼洏鐮�
-                locMast.setModiTime(now);
-                locMast.setModiUser(9999L);
-                locMastService.updateById(locMast);
-            }
-        }
-    }
-
-
-    public synchronized String CrnStartRunning(TaskWrk taskWrk) {
-        String tasktype = null;
-        switch (taskWrk.getIoType()) {
-            case 1:
-                tasktype = "RK";
-                break;
-            case 2:
-                tasktype = "CK";
-                break;
-            case 3:
-                tasktype = "YK";
-                break;
-            default:
-                tasktype = "鏈煡";
-        }
-        Map<String, Object> map = new HashMap<>();
-        map.put("x-api-key", "7a15b5db-29b6-552c-8cff-0cfec3756da2");
-        TaskOverToWms taskOverToWms = new TaskOverToWms();
-        taskOverToWms.setFeedbackFrom("WCS"); //鏉ユ簮
-        taskOverToWms.setWarehouseId("1688469798893297665"); //浠撳簱鏍囪瘑
-        taskOverToWms.setTaskNo(taskWrk.getTaskNo()); //浠诲姟鍙�
-        taskOverToWms.setTaskType(tasktype); // 浠诲姟绫诲瀷
-        taskOverToWms.setContainerCode(taskWrk.getBarcode()); // 瀹瑰櫒缂栫爜
-        if (taskWrk.getIoType() == 1 || taskWrk.getIoType() == 3) {
-            taskOverToWms.setEquipmentCode(String.valueOf(taskWrk.getCrnNo())); //璁惧缂栫爜
-            taskOverToWms.setTargetLocationCode(taskWrk.getOriginTargetPoint()); //鐩爣搴撲綅
-        } else if (taskWrk.getIoType() == 2) {
-            Map<Integer, String> map1 = new HashMap<>();
-            map1.put(102, "J-1101");
-            map1.put(106, "J-1103");
-            map1.put(110, "J-1105");
-            map1.put(114, "J-1107");
-            map1.put(118, "J-1109");
-            map1.put(122, "J-1111");
-            map1.put(305, "H-1101");
-            map1.put(405, "G-1101");
-            taskOverToWms.setEquipmentCode(map1.get(taskWrk.getTargetPoint())); //璁惧缂栫爜
-            taskOverToWms.setSourceLocationCode(taskWrk.getOriginStartPoint()); //婧愬簱浣�
-        }
-
-        taskOverToWms.setTaskStatus("executing"); //浠诲姟鐘舵��
-        String response = null;
-        try {
-            response = new HttpHandler.Builder()
-                    .setHeaders(map)
-                    .setUri(wmsUrl)
-                    .setPath("wcsManager/wcsInterface/taskStatusFeedback")
-                    .setJson(JSON.toJSONString(taskOverToWms))
-                    .build()
-                    .doPost();
-        } catch (Exception e) {
-            log.error("鍫嗗灈鏈轰换鍔″畬鎴愶紝璇锋眰wms浠诲姟瀹屾垚鎺ュ彛澶辫触");
-        }
-        apiLogService.save("鍫嗗灈鏈哄紑濮嬭繍琛�"
-                , wmsUrl + "wcsManager/wcsInterface/taskStatusFeedback"
-                , null
-                , "127.0.0.1"
-                , JSON.toJSONString(taskOverToWms)
-                , response
-                , true
-        );
-        return response;
-    }
 
     private TaskWrk createInTask(WmsResult result, String barcode, Integer startPoint) {
         //String locNo = Utils.Fusion(result.getRow(), result.getFloor(), result.getColumn());
diff --git a/src/main/java/com/zy/asrs/service/impl/ToWmsServiceImpl.java b/src/main/java/com/zy/asrs/service/impl/ToWmsServiceImpl.java
index 5cbbc86..59ee1da 100644
--- a/src/main/java/com/zy/asrs/service/impl/ToWmsServiceImpl.java
+++ b/src/main/java/com/zy/asrs/service/impl/ToWmsServiceImpl.java
@@ -2,23 +2,15 @@
 
 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.entity.BasDevp;
-import com.zy.asrs.entity.LocMast;
 import com.zy.asrs.entity.TaskWrk;
 import com.zy.asrs.entity.TaskWrkReport;
 import com.zy.asrs.entity.wms.StorageEscalationParam;
 import com.zy.asrs.entity.wms.WmsResult;
 import com.zy.asrs.service.*;
-import com.zy.asrs.utils.Utils;
 import com.zy.common.service.CommonService;
 import com.zy.common.utils.HttpHandler;
 import com.zy.common.utils.Synchro;
-import com.zy.core.cache.MessageQueue;
-import com.zy.core.enums.SlaveType;
-import com.zy.core.model.Task;
 import com.zy.core.properties.SlaveProperties;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
@@ -26,7 +18,6 @@
 
 import java.io.IOException;
 import java.util.Date;
-import java.util.HashMap;
 
 @Service
 public class ToWmsServiceImpl implements ToWmsService {
@@ -81,8 +72,9 @@
 
     @Value("${wms.data}")
     private String data;
-@Override
-public void addReportLog(TaskWrk taskWrk) {
+
+    @Override
+    public void addReportLog(TaskWrk taskWrk) {
         TaskWrkReport taskWrkReport = new TaskWrkReport();
         Synchro.Copy(taskWrk, taskWrkReport);
         taskWrkReport.setCreateTime(new Date());
@@ -111,82 +103,6 @@
             addApiLog("鍏ュ簱浠诲姟璇锋眰鑾峰彇搴撲綅", wmsUrl + inboundTaskApplyPath, JSON.toJSONString(wmsParam), response, success);
         }
         return null;
-    }
-
-    public boolean checkLocNo(String locNo) {
-        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);
-            }
-        }
     }
 
 
diff --git a/src/main/java/com/zy/core/ServerBootstrap.java b/src/main/java/com/zy/core/ServerBootstrap.java
index 1858d01..a253991 100644
--- a/src/main/java/com/zy/core/ServerBootstrap.java
+++ b/src/main/java/com/zy/core/ServerBootstrap.java
@@ -28,8 +28,7 @@
     private SlaveProperties slaveProperties;
     @Autowired
     private MainProcess mainProcess;
-    @Autowired
-    private MainCpProcess cpMainProcess;
+
 
     /**
      * PostConstruct浼氬湪鍔犺浇servlet鐨勬椂鍊欒繍琛屼竴娆�
@@ -46,7 +45,7 @@
         initThread();
         // 寮�濮嬩富娴佺▼杩涚▼
         mainProcess.start();
-        cpMainProcess.start();
+
         log.info("鏍稿績鎺у埗灞傚凡鍚姩...............................................");
     }
 
diff --git a/src/main/java/com/zy/core/thread/SiemensDevpThread.java b/src/main/java/com/zy/core/thread/SiemensDevpThread.java
index 181516f..6a5db1e 100644
--- a/src/main/java/com/zy/core/thread/SiemensDevpThread.java
+++ b/src/main/java/com/zy/core/thread/SiemensDevpThread.java
@@ -731,26 +731,26 @@
 
     // 鏇存柊鍏ュ嚭搴撴ā寮�
     private void updateIoMode() throws InterruptedException {
-        if (slave.getId() == 2 && this.ioModeOf2F != null) {
-            if (!siemensS7Net.Write("DB4.2", this.ioModeOf2F.id).IsSuccess) {
+        if (slave.getId() == 1 && this.ioModeOf1F1 != null) {
+            if (!siemensS7Net.Write("DB4.2", this.ioModeOf1F1.id).IsSuccess) {
                 OutputQueue.DEVP.offer(MessageFormat.format("銆恵0}銆戝啓鍏ヨ緭閫佺嚎21F1鍏ュ嚭搴撴ā寮忓け璐ャ�傝緭閫佺嚎plc缂栧彿={2}", slave.getId()));
                 log.error("鍐欏叆杈撻�佺嚎2F1鍏ュ嚭搴撴ā寮忓け璐ャ�傝緭閫佺嚎plc缂栧彿={}", slave.getId());
             }
         }
-        if (slave.getId() == 2 && this.ioModeOf2F != null) {
-            if (!siemensS7Net.Write("DB4.4", this.ioModeOf2F.id).IsSuccess) {
+        if (slave.getId() == 1 && this.ioModeOf1F2 != null) {
+            if (!siemensS7Net.Write("DB4.4", this.ioModeOf1F2.id).IsSuccess) {
                 OutputQueue.DEVP.offer(MessageFormat.format("銆恵0}銆戝啓鍏ヨ緭閫佺嚎2F2鍏ュ嚭搴撴ā寮忓け璐ャ�傝緭閫佺嚎plc缂栧彿={3}", slave.getId()));
                 log.error("鍐欏叆杈撻�佺嚎2F2鍏ュ嚭搴撴ā寮忓け璐ャ�傝緭閫佺嚎plc缂栧彿={}", slave.getId());
             }
         }
-        if (slave.getId() == 3 && this.ioModeOf2F != null) {
-            if (!siemensS7Net.Write("DB4.2", this.ioModeOf2F.id).IsSuccess) {
+        if (slave.getId() == 1 && this.ioModeOf1F2 != null) {
+            if (!siemensS7Net.Write("DB4.2", this.ioModeOf1F2.id).IsSuccess) {
                 OutputQueue.DEVP.offer(MessageFormat.format("銆恵0}銆戝啓鍏ヨ緭閫佺嚎3F1鍏ュ嚭搴撴ā寮忓け璐ャ�傝緭閫佺嚎plc缂栧彿={2}", slave.getId()));
                 log.error("鍐欏叆杈撻�佺嚎3F1鍏ュ嚭搴撴ā寮忓け璐ャ�傝緭閫佺嚎plc缂栧彿={}", slave.getId());
             }
         }
-        if (slave.getId() == 3 && this.ioModeOf2F != null) {
-            if (!siemensS7Net.Write("DB4.4", this.ioModeOf2F.id).IsSuccess) {
+        if (slave.getId() == 1 && this.ioModeOf1F2 != null) {
+            if (!siemensS7Net.Write("DB4.4", this.ioModeOf1F2.id).IsSuccess) {
                 OutputQueue.DEVP.offer(MessageFormat.format("銆恵0}銆戝啓鍏ヨ緭閫佺嚎3F2鍏ュ嚭搴撴ā寮忓け璐ャ�傝緭閫佺嚎plc缂栧彿={3}", slave.getId()));
                 log.error("鍐欏叆杈撻�佺嚎3F2鍏ュ嚭搴撴ā寮忓け璐ャ�傝緭閫佺嚎plc缂栧彿={}", slave.getId());
             }

--
Gitblit v1.9.1