2f856385474c1624b76bd1029838f33dadd65648..2a7fd275313003968fc186ee4617aec4eca90266
2025-05-10 Junjie
#
2a7fd2 对比 | 目录
2025-05-10 Junjie
#
dc4df4 对比 | 目录
2025-05-10 Junjie
#
268a7f 对比 | 目录
2025-05-10 taisheng
#
accd3d 对比 | 目录
2025-05-10 taisheng
#
52c263 对比 | 目录
2025-05-10 Junjie
#
470ddb 对比 | 目录
3个文件已添加
11个文件已修改
1613 ■■■■ 已修改文件
src/main/java/com/zy/asrs/controller/OpenController.java 182 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/java/com/zy/asrs/domain/enums/WorkNoType.java 27 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/java/com/zy/asrs/entity/param/GenerateAgvTaskParam.java 14 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/java/com/zy/asrs/entity/param/TaskCreateParam.java 1 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/java/com/zy/asrs/service/OpenService.java 11 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java 818 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/java/com/zy/asrs/service/impl/OpenServiceImpl.java 321 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/java/com/zy/asrs/task/AgvTaskLogScheduler.java 77 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/java/com/zy/asrs/task/AssignAgvTaskScheduler.java 115 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/java/com/zy/core/MainProcess.java 21 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/java/com/zy/core/thread/SiemensDevpThread.java 20 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/resources/application.yml 6 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
src/main/resources/license.lic 补丁 | 查看 | 原始文档 | blame | 历史
src/main/resources/sql/tswcs_sxk.bak 补丁 | 查看 | 原始文档 | blame | 历史
src/main/java/com/zy/asrs/controller/OpenController.java
@@ -3,12 +3,11 @@
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.annotations.AppAuth;
import com.core.common.BaseRes;
import com.core.common.Cools;
import com.core.common.R;
import com.core.exception.CoolException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zy.asrs.domain.enums.TaskStatusType;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.service.*;
@@ -16,16 +15,12 @@
import com.zy.common.web.BaseController;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.*;
import static org.apache.ibatis.ognl.OgnlRuntime.setFieldValue;
@Slf4j
@RestController
@@ -53,32 +48,37 @@
    @Autowired
    private BasCrnErrorService basCrnErrorService;
    @Value("${wms.url}")
    private String wmsUrl;
    private static final boolean auth = true;
    public static final ArrayList<String> APP_KEY_LIST = new ArrayList<String>() {{
        add("ea1f0459efc02a79f046f982767939ae");
    }};
    //agv任务完成
    @PostMapping("/toAgvTaskOver")
    @AppAuth(memo = "agv任务完成接口")
    public R getAgvTaskOver(@RequestHeader String appkey,
                           @RequestBody TaskOverParam param,
                           HttpServletRequest request){
        auth(appkey, param, request);
        if (Cools.isEmpty(param)) {
            return R.parse(BaseRes.PARAM);
    //AGV上报
    @PostMapping("/agvReport")
    public R agvReport(@RequestBody HashMap<String, Object> param) {
        String taskCode = param.get("taskCode").toString();
        System.out.println(JSON.toJSONString(param));
        TaskWrk taskWrk = taskWrkService.selectByTaskNo(taskCode);
        if(taskWrk == null) {
            return R.error("任务不存在");
        }
        if (Cools.isEmpty(param.getWharfCode())){
            return R.error("码头[wharfCode]不能为空");
        }
        if (Cools.isEmpty(param.getStatus())){
            return R.error("完成标记[status]不能为空");
        }
        openService.getAgvTaskOver(param);
        taskWrk.setStatus(TaskStatusType.COMPLETE.id);
        taskWrk.setModiTime(new Date());
        taskWrkService.updateById(taskWrk);
        return R.ok();
    }
    //生成AGV任务
    @PostMapping("/generateAgvTask")
    public R generateAgvTask(@RequestBody GenerateAgvTaskParam param) {
        boolean generated = openService.generateAgvTask(param);
        if(generated) {
            return R.ok();
        }
        return R.error();
    }
    //创建任务
@@ -158,44 +158,6 @@
        return R.ok().add(taskWrk);
    }
    //取放货申请
    @PostMapping("/pick/and/place/v1")
    @AppAuth(memo = "agv取放货申请")
    public R getAgvPickAndPlaceV1(@RequestHeader String appkey,
                            @RequestBody TaskOverParam param,
                            HttpServletRequest request){
        auth(appkey, param, request);
        if (Cools.isEmpty(param)) {
            return R.parse(BaseRes.PARAM);
        }
        if (Cools.isEmpty(param.getStaNo())){
            return R.error("码头[staNo]不能为空");
        }
        if (Cools.isEmpty(param.getType())){
            return R.error("类型[type]不能为空");
        }
        return openService.getAgvPickAndPlaceV1(param);
    }
    //取放货完成反馈
    @PostMapping("/pick/and/place/v2")
    @AppAuth(memo = "agv取放货完成反馈")
    public R getAgvPickAndPlaceV2(@RequestHeader String appkey,
                                  @RequestBody TaskOverParam param,
                                  HttpServletRequest request){
        auth(appkey, param, request);
        if (Cools.isEmpty(param)) {
            return R.parse(BaseRes.PARAM);
        }
        if (Cools.isEmpty(param.getStaNo())){
            return R.error("码头[staNo]不能为空");
        }
        if (Cools.isEmpty(param.getType())){
            return R.error("类型[type]不能为空");
        }
        return openService.getAgvPickAndPlaceV2(param);
    }
    //查询任务指令集合
    @GetMapping("/queryTaskCommand")
    public R queryTaskCommand(@RequestHeader String appkey,
@@ -220,100 +182,6 @@
        if (!APP_KEY_LIST.contains(appkey)) {
            throw new CoolException("认证失败,请确认appkey无误!");
        }
    }
    //AGV请求入库码头接口
    @PostMapping("/targetWharfApply")
    @AppAuth(memo = "AGV请求入库码头接口")
    public R targetWharfApply(@RequestHeader String appkey,
                              @RequestBody WMSAndAGVInterfaceParam param,
                              HttpServletRequest request) throws IOException {
        auth(appkey,param,request);
        if (Cools.isEmpty(param)){
            return R.error("参数为空!");
        } else if (Cools.isEmpty(param.getTaskNo())){
            return R.error("工作号为空!");
        } else if (Cools.isEmpty(param.getContainerCode())){
            return R.error("托盘编码为空!");
        } else if (Cools.isEmpty(param.getWharfSource())){
            return R.error("源码头为空!");
        } else if (Cools.isEmpty(param.getFreeWharfs()) || param.getFreeWharfs().size()==0){
            return R.error("空闲的入库码头(AGV)为空!");
        }
        R r = openService.AgvToWCSToWms(param);
        apiLogService.save("AGV请求入库码头接口"
                ,request.getRemoteAddr()+request.getRequestURI()
                ,appkey
                ,request.getRemoteAddr()
                ,JSON.toJSONString(param)
                ,r.toString()
                ,true
        );
        return r;
    }
    //AGV请求动作接口
    @PostMapping("/agvTaskRequest")
    @AppAuth(memo = "AGV请求动作接口")
    public R agvTaskRequest(@RequestHeader String appkey,
                              @RequestBody WMSAndAGVInterfaceParam param,
                              HttpServletRequest request) {
        auth(appkey, param, request);
        if (Cools.isEmpty(param)){
            return R.error("参数为空!");
        } else if (Cools.isEmpty(param.getRequestType())){
            return R.error("请求类型为空!");
        } else if (Cools.isEmpty(param.getWharfCode())){
            return R.error("码头编号为空!");
        }
        Map<String,Integer> map = new HashMap<>();
        map.put("J-1102",102);map.put("J-1101",101);
        map.put("J-1103",105);map.put("J-1104",106);
        map.put("J-1105",109);map.put("J-1106",110);
        map.put("J-1107",113);map.put("J-1108",114);
        map.put("J-1109",117);map.put("J-1110",118);
        map.put("J-1111",121);map.put("J-1112",122);
        map.put("H-1102",300);map.put("H-1101",305);
        map.put("G-1102",400);map.put("G-1101",405);
//        StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
//                .eq("stn_desc", param.getWharfCode()));
//
//        if (Cools.isEmpty(staDesc)){
//            return R.error("程序报错,未查询到站点");
//        }
        if (Cools.isEmpty(map.get(param.getWharfCode()))){
            return R.error("未查询到站点");
        }
        BasDevp basDevp = basDevpService.selectById(map.get(param.getWharfCode()));
//        BasDevp basDevp = basDevpService.selectById(staDesc.getStnNo());
        if (basDevp.getAutoing().equals("Y") && (basDevp.getInEnable().equals("Y") || basDevp.getOutEnable().equals("Y"))){
            apiLogService.save("AGV请求入库码头接口"
                    ,request.getRemoteAddr()+request.getRequestURI()
                    ,appkey
                    ,request.getRemoteAddr()
                    ,JSON.toJSONString(param)
                    ,R.ok().toString()
                    ,true
            );
            return R.ok("可入");
        }else {
            apiLogService.save("AGV请求入库码头接口"
                    ,request.getRemoteAddr()+request.getRequestURI()
                    ,appkey
                    ,request.getRemoteAddr()
                    ,JSON.toJSONString(param)
                    ,R.error("站点状态不可入").toString()
                    ,true
            );
            return R.error("站点状态不可入");
        }
    }
    //任务下发接口
src/main/java/com/zy/asrs/domain/enums/WorkNoType.java
@@ -11,38 +11,13 @@
    PICK(1),
    PAKOUT(2),
    OTHER(3),
    AGV(4),
    ;
    public Integer type;
    WorkNoType(Integer type) {
        this.type = type;
    }
    public static Integer getWorkNoType(Integer ioType) {
        switch (ioType) {
            case 1:
                return PAKIN.type;
            case 10:
                return PAKIN.type;
            case 11:
                return PICK.type;
            case 53:
            case 54:
            case 57:
                return PICK.type;
            case 101:
                return PAKOUT.type;
            case 103:
            case 104:
            case 107:
                return PICK.type;
            case 110:
                return PAKOUT.type;
            default:
                break;
        }
        throw new CoolException(ioType + "的任务类型无法生成工作号");
    }
}
src/main/java/com/zy/asrs/entity/param/GenerateAgvTaskParam.java
New file
@@ -0,0 +1,14 @@
package com.zy.asrs.entity.param;
import lombok.Data;
@Data
public class GenerateAgvTaskParam {
    //取货点
    private String originPoint;
    //放货点
    private String targetPoint;
}
src/main/java/com/zy/asrs/entity/param/TaskCreateParam.java
@@ -1,6 +1,5 @@
package com.zy.asrs.entity.param;
import io.swagger.models.auth.In;
import lombok.Data;
@Data
src/main/java/com/zy/asrs/service/OpenService.java
@@ -1,11 +1,8 @@
package com.zy.asrs.service;
import com.core.common.R;
import com.zy.asrs.entity.param.TaskOverParam;
import com.zy.asrs.entity.param.WMSAndAGVInterfaceParam;
import com.zy.asrs.entity.param.GenerateAgvTaskParam;
import com.zy.asrs.entity.param.TaskCreateParam;
import java.io.IOException;
import java.util.HashMap;
public interface OpenService {
@@ -13,10 +10,6 @@
    //创建任务
    HashMap<String,Object> taskCreate(TaskCreateParam param);
    R AgvToWCSToWms(WMSAndAGVInterfaceParam param) throws IOException;
    boolean generateAgvTask(GenerateAgvTaskParam param);
    void getAgvTaskOver(TaskOverParam param);
    R getAgvPickAndPlaceV1(TaskOverParam param);
    R getAgvPickAndPlaceV2(TaskOverParam param);
}
src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
@@ -3,39 +3,21 @@
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.OpenController;
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.param.Result;
import com.zy.asrs.entity.param.StorageEscalationParam;
import com.zy.asrs.entity.param.TaskOverToWms;
import com.zy.asrs.entity.param.GenerateAgvTaskParam;
import com.zy.asrs.mapper.*;
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.CommandPackage;
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;
@@ -44,14 +26,12 @@
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.*;
/**
 * 立体仓库WCS系统主流程业务
 * Created by vincent on 2020/8/6
 */
@Slf4j
@Service("mainService")
@@ -63,17 +43,9 @@
    @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
@@ -84,236 +56,104 @@
    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;
    private OpenService openService;
    @Value("${wcs.urlWcs}")
    private String wcsUrl;
    @Value("${wcs.inboundTaskApplyPathWcs}")
    private String wcsInboundTaskApplyPath;
    @Autowired
    private CrnController crnController;
    @Autowired
    private SiteController siteController;
    public synchronized 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.isFrontErr()) {
                        errMsg = "前超限";
                        back = true;
                    }
                    if (!back && staProtocol.isBackErr()) {
                        errMsg = "后超限";
                        back = true;
                    }
                    if (!back && staProtocol.isHighErr()) {
                        errMsg = "高超限";
                        back = true;
                    }
                    if (!back && staProtocol.isLeftErr()) {
                        errMsg = "左超限";
                        back = true;
                    }
                    if (!back && staProtocol.isRightErr()) {
                        errMsg = "右超限";
                        back = true;
                    }
                    if (!back && staProtocol.isWeightErr()) {
                        errMsg = "超重";
                        back = true;
                    }
                    if (!back && staProtocol.isBarcodeErr()) {
                        errMsg = "扫码失败";
                        back = true;
                    }
                    // 判断是否满足入库条件
                    if (staProtocol.isAutoing() && staProtocol.isLoading()
                            && staProtocol.isInEnable()
                            && !staProtocol.isEmptyMk() && workNo >= 9790
                            && staProtocol.isPakMk()) {
                        // 获取条码扫描仪信息
                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
                        if (barcodeThread == null) {
                            continue;
                        }
                        String BoxNo = barcodeThread.getBarcode();
                        TaskWrk taskWrk1 = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", BoxNo));
                        if (!Cools.isEmpty(taskWrk1)) {
                            log.info("托盘码:" + BoxNo + "任务档存在");
                            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) {
                                if (staProtocol.getWorkNo() >= 9801 && staProtocol.getWorkNo() <= 9825) {
                                    staProtocol.setStaNo((short) 105);
                                } else if (staProtocol.getWorkNo() >= 9826 && staProtocol.getWorkNo() <= 9850) {
                                    staProtocol.setStaNo((short) 107);
                                } else if (staProtocol.getWorkNo() >= 9851 && staProtocol.getWorkNo() <= 9875) {
                                    staProtocol.setStaNo((short) 109);
                                } else {
                                    staProtocol.setStaNo((short) 110);
                                }
                                devpThread.setPakMk(staProtocol.getSiteId(), false);
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            } else {
                                if (!Cools.isEmpty(response) && !Cools.isEmpty(jsonObject.get("ReturnStatus")) && jsonObject.get("ReturnStatus").equals(0) && !Cools.isEmpty(jsonObject.get("Result").toString())) {
                                    Result result = JSON.parseObject(jsonObject.get("Result").toString(), Result.class);
                                    // 创新一个入库工作档
                                    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 {
                                                //开始上报,任务开始时,WCS回调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开始入库任务上报wms"
                                                        , wmsUrl + TaskExecCallback
                                                        , null
                                                        , "127.0.0.1"
                                                        , JSON.toJSONString(hashMap)
                                                        , response
                                                        , bool
                                                );
                                            } catch (Exception e) {
                                            }
                                        }
                                    } else {
//                                    staProtocol.setWorkNo((short) 9991);
                                        if (staProtocol.getWorkNo() >= 9801 && staProtocol.getWorkNo() <= 9825) {
                                            staProtocol.setStaNo((short) 105);
                                        } else if (staProtocol.getWorkNo() >= 9826 && staProtocol.getWorkNo() <= 9850) {
                                            staProtocol.setStaNo((short) 107);
                                        } else if (staProtocol.getWorkNo() >= 9851 && staProtocol.getWorkNo() <= 9875) {
                                            staProtocol.setStaNo((short) 109);
                                        } else {
                                            staProtocol.setStaNo((short) 110);
                                        }
                                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                    }
                                } else {
//                                staProtocol.setWorkNo((short) 9991);
                                    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 synchronized void demo() {
        boolean demoEnable = false;
        Config demoEnableConfig = configService.selectByCode("demoEnable");
        if(demoEnableConfig != null) {
            demoEnable = Boolean.parseBoolean(demoEnableConfig.getValue());
        }
        if (!demoEnable) {
            return;
        }
        //演示模式-AGV出库
        demoAgvOut();
        //演示模式-AGV入库
        demoAgvIn();
        //演示模式-四向库出库
        demoShuttleOut();
        //演示模式-四向库入库
        demoShuttleIn();
    }
    //演示模式-AGV出库
    private synchronized void demoAgvOut() {
        LocMast locMast = locMastService.selectByLocNo("1100601");
        if(locMast == null) {
            return;
        }
        if (!locMast.getLocSts().equals("O")) {
            return;
        }
        List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
                .eq("mk", "agv")
                .eq("loc_sts", "F")
                .notIn("loc_no", "0900601")
        );
        if (locMasts.isEmpty()) {
            return;
        }
        LocMast originLocMast = locMasts.get(0);
        //生成AGV出库任务
        GenerateAgvTaskParam param = new GenerateAgvTaskParam();
        param.setOriginPoint(originLocMast.getLocNo());
        param.setTargetPoint(locMast.getLocNo());
        openService.generateAgvTask(param);
    }
    //演示模式-AGV入库
    private synchronized void demoAgvIn() {
        LocMast locMast = locMastService.selectByLocNo("0900601");
        if(locMast == null) {
            return;
        }
        if (!locMast.getLocSts().equals("F")) {
            return;
        }
        List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>()
                .eq("mk", "agv")
                .eq("loc_sts", "O")
                .notIn("loc_no", "1100601")
        );
        if (locMasts.isEmpty()) {
            return;
        }
        LocMast targetLocMast = locMasts.get(0);
        //生成AGV出库任务
        GenerateAgvTaskParam param = new GenerateAgvTaskParam();
        param.setOriginPoint(locMast.getLocNo());
        param.setTargetPoint(targetLocMast.getLocNo());
        openService.generateAgvTask(param);
    }
    //演示模式-四向库出库
    private synchronized void demoShuttleOut() {
    }
    //演示模式-四向库入库
    private synchronized void demoShuttleIn() {
    }
    /**
@@ -564,345 +404,6 @@
        }
    }
    /**
     * 库位移转
     */
    public synchronized void locToLoc(CrnSlave slave, CrnProtocol crnProtocol) {
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11(生成出库ID)的移库工作档
            List<TaskWrk> taskWrks = taskWrkMapper.selectList(new EntityWrapper<TaskWrk>()
                    .eq("crn_no", slave.getId())
                    .eq("wrk_sts", 11)
                    .eq("io_type", 3)
                    .orderBy("io_pri", false));
            for (TaskWrk taskWrk : taskWrks) {
                // 双深库位且浅库位有货,则需先对浅库位进行库位移转
//                if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
//                    String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
//                    TaskWrk hallowLocNoTask = taskWrkMapper.selectByStartPoint(shallowLocNo);
//                    if (!Cools.isEmpty(hallowLocNoTask)){
//                        continue;
//                    }
//                }
                // 堆垛机控制过滤
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                    continue;
                }
                // 已经存在吊车执行任务时,则过滤
                if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                    continue;
                }
                if (taskWrk == null || Cools.isEmpty(taskWrk.getTargetPoint()) || taskWrk.getTargetPoint().equals("") || taskWrk.getWrkNo() == null) {
                    continue;
                }
                // 工作档状态判断
                if (taskWrk.getIoType() != 3 || taskWrk.getTargetPoint() == null) {
                    log.error("查询工作档数据不符合条件--入出类型/目标库位号, 工作号={},源库位={},入出类型={}", taskWrk.getWrkNo(), taskWrk.getTargetPoint(), taskWrk.getIoType());
                    continue;
                }
                // 命令下发区 --------------------------------------------------------------------------
                // 1.堆垛机开始移动
                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 {
                    // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                    Date now = new Date();
                    taskWrk.setWrkSts(12);
                    taskWrk.setStatus(2);
                    taskWrk.setModiTime(now);
                    if (taskWrkMapper.updateById(taskWrk) == 0) {
                        log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败!!,工作号={}", taskWrk.getWrkNo());
                    }
                    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派发移库库任务上报wms失败", taskWrk);
//                        throw new CoolException("wcs派发移库库任务上报wms失败");
                    }
                }
                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("堆垛机处于等待确认且任务完成状态,但未找到工作档。堆垛机号={},工作号={}", crn.getId(), crnProtocol.getTaskNo());
//                    continue;
//                }
//
//                //获取指令ID
//                Integer commandId = crnProtocol.getCommandId();
//                CommandInfo commandInfo = new CommandInfo();
//                if (Cools.isEmpty(commandId)){
//                    commandInfo = commandInfoService.selectOne(new EntityWrapper<CommandInfo>()
//                            .eq("wrk_no",crnProtocol.getTaskNo())
//                            .eq("device","Crn"));
//                }else {
//                    commandInfo = commandInfoService.selectById(commandId);
//                }
//
//
//                if (commandInfo == null) {
//                    //指令不存在
//                    continue;
//                }
//                if (commandInfo.getCommandStatus() == 3){
//                    continue;
//                }
//                commandInfo.setCommandStatus(CommandStatusType.COMPLETE.id);//指令完成
//                commandInfo.setCompleteTime(new Date());//指令完成时间
//                if (commandInfoService.updateById(commandInfo)) {//修改成功后复位堆垛机
//                    // 堆垛机复位
//                    crnThread.setResetFlag(true);
//                }
//            }
//        }
//    }
    /**
     * 执行对工作档的完成操作
     */
    public synchronized void storeFinished() throws InterruptedException {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) {
                continue;
            }
            //  状态:等待确认 并且  任务完成位 = 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("堆垛机处于等待确认且任务完成状态,但未找到工作档。堆垛机号={},工作号={}", 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 synchronized 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("堆垛机plc异常记录失败 ===>> [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("堆垛机plc异常记录修复失败 ===>> [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("堆垛机plc异常记录失败 ===>> [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("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
                            }
                        }
                    }
                }
            }
        }
    }
    //自动派发任务
    public synchronized void autoDistribute() {
        Config config = configService.selectByCode("autoDistribute");
@@ -1030,145 +531,6 @@
                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(Result 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;
    }
}
src/main/java/com/zy/asrs/service/impl/OpenServiceImpl.java
@@ -1,34 +1,19 @@
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.domain.enums.TaskStatusType;
import com.zy.asrs.domain.enums.WorkNoType;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.TaskOverParam;
import com.zy.asrs.entity.param.WMSAndAGVInterfaceParam;
import com.zy.asrs.entity.param.GenerateAgvTaskParam;
import com.zy.asrs.entity.param.TaskCreateParam;
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.core.DevpThread;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.SlaveType;
import com.zy.core.model.DevpSlave;
import com.zy.core.model.Task;
import com.zy.core.model.protocol.StaProtocol;
import com.zy.core.properties.SlaveProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.*;
@Service
@@ -37,33 +22,9 @@
    @Autowired
    private TaskWrkService taskWrkService;
    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private ApiLogService apiLogService;
    @Autowired
    private StaDescService staDescService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private BasDevpService basDevpService;
    @Value("${wms.url}")
    private String wmsUrl;
    public ArrayList<String> wharfCode1 = new ArrayList<String>() {{
        add("J-1101");
        add("J-1103");
        add("J-1105");
        add("J-1107");
        add("J-1109");
        add("J-1111");
        add("H-1101");
        add("G-1101");
    }};
    @Override
    public HashMap<String, Object> taskCreate(TaskCreateParam param) {
@@ -133,247 +94,53 @@
    }
    @Override
    public R AgvToWCSToWms(WMSAndAGVInterfaceParam param) throws IOException {
        ToWmsDTO toWmsDTO = new ToWmsDTO();
        Map<String, Object> map = new HashMap<>();
        map.put("x-api-key", "7a15b5db-29b6-552c-8cff-0cfec3756da2");
        List<Integer> list = new ArrayList<>();
        if (param.getWharfSource().contains("J")) {
            list = getInEnableRoadway();
        } else {
            list = getInEnableRoadway2();
    public boolean generateAgvTask(GenerateAgvTaskParam param) {
        Date now = new Date();
        String originPoint = param.getOriginPoint();
        String targetPoint = param.getTargetPoint();
        LocMast startLocMast = locMastService.selectByLocNo(originPoint);
        if(startLocMast == null){
            throw new CoolException("取货点库位不存在");
        }
        //TaskWrk taskWrk = taskWrkService.selectByTaskNo(param.getTaskNo());
        toWmsDTO.setWarehouseId("1688469798893297665");
        toWmsDTO.setContainerCode(param.getContainerCode());
        toWmsDTO.setApplyType("TUNNEL");
        toWmsDTO.setWharfSource(null);
        toWmsDTO.setCanInboundTunnels(list);
        String response = null;
        try {
            response = new HttpHandler.Builder()
                    .setHeaders(map)
                    .setUri(wmsUrl)
                    .setPath("wcsManager/wcsInterface/inboundTaskApply")
                    .setJson(JSON.toJSONString(toWmsDTO))
                    .build()
                    .doPost();
        } catch (Exception e) {
            return R.error("wms连接失败" + e.getMessage());
        if (!startLocMast.getLocSts().equals("F")) {
            throw new CoolException("取货点不处于在库");
        }
        JSONObject jsonObject = JSON.parseObject(response);
        apiLogService.save("wms请求入库码头接口"
                , wmsUrl + "wcsManager/wcsInterface/inboundTaskApply"
                , null
                , "127.0.0.1"
                , JSON.toJSONString(toWmsDTO)
                , response
                , true
        );
        if (jsonObject.getInteger("code").equals(200)) {
            //解析
            List<WMSAndAGVInterfaceParam> params = new ArrayList<>();
            params.add(param);
            WMSAndAGVInterfaceParam data = JSONObject.parseObject(jsonObject.get("data").toString(), WMSAndAGVInterfaceParam.class);
            String msg = null;
            try {
                taskCreate(new TaskCreateParam(data));
            } catch (Exception e) {
                msg = e.getMessage();
            }
            if (msg != null) {
                return R.error(msg);
            }
            Map<String, String> map1 = new HashMap<>();
            StaDesc staDesc = new StaDesc();
            if (param.getWharfSource().contains("J")) {
                staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                        .eq("crn_no", data.getTaskTunnel())
                        .eq("type_no", 1)
                        .lt("stn_no", 200));
            } else if (param.getWharfSource().contains("H")) {
                staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                        .eq("crn_no", data.getTaskTunnel())
                        .eq("type_no", 1)
                        .lt("stn_no", 400)
                        .gt("stn_no", 200));
            } else {
                staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                        .eq("crn_no", data.getTaskTunnel())
                        .eq("type_no", 1)
                        .lt("stn_no", 500)
                        .ge("stn_no", 400));
            }
            map1.put("taskTunnel", staDesc.getStnDesc());
            //map1.put("taskTunnel", "J-1104");
            return R.ok(map1);
        LocMast targetLocMast = locMastService.selectByLocNo(targetPoint);
        if(targetLocMast == null){
            throw new CoolException("放货点库位不存在");
        }
        return R.error((String) jsonObject.get("msg"));
        if (!targetLocMast.getLocSts().equals("O")) {
            throw new CoolException("放货点不处于空库");
        }
        TaskWrk taskWrk = new TaskWrk();
        int workNo1 = commonService.getWorkNo(WorkNoType.AGV.type);//获取AGV工作号
        taskWrk.setTaskNo(String.valueOf(workNo1));//任务号
        taskWrk.setWrkNo(workNo1);
        taskWrk.setStatus(TaskStatusType.RECEIVE.id);//任务状态:接收
        taskWrk.setCreateTime(now);
        taskWrk.setWrkSts(11);
        taskWrk.setIoType(4);//AGV搬运
        taskWrk.setStartPoint(param.getOriginPoint());//取货点
        taskWrk.setTargetPoint(param.getTargetPoint());//放货点
        boolean insert = taskWrkService.insert(taskWrk);
        if (!insert) {
            throw new CoolException("任务生成失败");
        }
        startLocMast.setLocSts("R");
        startLocMast.setModiTime(now);
        locMastService.updateById(startLocMast);
        targetLocMast.setLocSts("S");
        targetLocMast.setModiTime(now);
        locMastService.updateById(targetLocMast);
        return true;
    }
    @Override
    public void getAgvTaskOver(TaskOverParam param) {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                    .eq("stn_desc", param.getWharfCode()));
            if (Cools.isEmpty(staDesc)) {
                throw new RuntimeException("未查询到站点信息");
            }
            // 获取入库站信息
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
            StaProtocol staProtocol = devpThread.getStation().get(staDesc.getStnNo());
            if (staProtocol == null) {
                continue;
            } else {
                staProtocol = staProtocol.clone();
            }
            Short workNo = staProtocol.getWorkNo();
            if (wharfCode1.contains(param.getWharfCode())) {
                if (!staProtocol.isLoading() && !staProtocol.isCar() && staProtocol.getWorkNo() > 0) {
                    //AGV出库完成以后
                    staProtocol.setWorkNo((short) 0);
                    staProtocol.setStaNo((short) 0);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
                    if (result) {
                    } else {
                        throw new RuntimeException("agv返回完成后,命令下发失败");
                    }
                }
            } else {
                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    if (inSta.getBackSta().equals(staDesc.getStnNo())) {
                        if (staProtocol.isLoading() && !staProtocol.isCar() && workNo == 0) {
                            //AGV入库完成以后
                            staProtocol.setWorkNo((short) 9999);
                            staProtocol.setStaNo(inSta.getStaNo().shortValue());
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(3, staProtocol));
                            if (result) {
                            } else {
                                throw new RuntimeException("agv返回完成后,命令下发失败");
                            }
                        }
                    }
                }
            }
        }
    }
    @Override
    public R getAgvPickAndPlaceV1(TaskOverParam param) {
        BasDevp basDevp = basDevpService.selectById(param.getStaNo());
        if (Cools.isEmpty(basDevp)) {
            return R.error("站点号有误" + param.getStaNo());
        }
        if (param.getType() == 0 && basDevp.getAgvStartPick() == 1) {
            return R.ok();
        } else if (param.getType() == 1 && basDevp.getAgvStartPlace() == 1) {
            return R.ok();
        } else {
            return R.error("不允许");
        }
    }
    @Override
    public R getAgvPickAndPlaceV2(TaskOverParam param) {
        BasDevp basDevp = basDevpService.selectById(param.getStaNo());
        if (Cools.isEmpty(basDevp)) {
            return R.error("站点号有误" + param.getStaNo());
        }
        if (param.getType() == 0) {
            basDevp.setAgvTargetPick(1);
            basDevpService.updateById(basDevp);
            return R.ok();
        } else if (param.getType() == 1) {
            basDevp.setAgvTargetPlace(1);
            basDevpService.updateById(basDevp);
            return R.ok();
        } else {
            return R.error("请求类型异常" + param.getType());
        }
    }
    public List<Integer> getInEnableRoadway() {
        int[] roadway = null;
        List<Integer> list = new ArrayList<>();
        Map<Integer, Integer> map = new HashMap<>();
        map.put(103, 1);
        map.put(107, 2);
        map.put(111, 3);
        map.put(115, 4);
        map.put(119, 5);
        map.put(123, 6);
        //put(301,7);
        // 根据输送线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.getBackSta());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                Short workNo = staProtocol.getWorkNo();
                if (workNo == 0 && !staProtocol.isLoading()) {
                    if (Cools.isEmpty(map.get(inSta.getStaNo()))) {
                        continue;
                    }
                    list.add(map.get(inSta.getStaNo()));
                }
            }
        }
        //roadway = list.stream().mapToInt(Integer::intValue).toArray();
        return list;
    }
    public List<Integer> getInEnableRoadway2() {
        int[] roadway = null;
        List<Integer> list = new ArrayList<>();
        Map<Integer, Integer> map = new HashMap<>();
        map.put(205, 1);
        map.put(211, 2);
        map.put(217, 3);
        map.put(223, 4);
        map.put(229, 5);
        map.put(235, 6);
        //put(301,7);
        // 根据输送线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.getBackSta());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                Short workNo = staProtocol.getWorkNo();
                if (workNo == 0 && !staProtocol.isLoading()) {
                    if (Cools.isEmpty(map.get(inSta.getStaNo()))) {
                        continue;
                    }
                    list.add(map.get(inSta.getStaNo()));
                }
            }
        }
        //roadway = list.stream().mapToInt(Integer::intValue).toArray();
        return list;
    }
}
src/main/java/com/zy/asrs/task/AgvTaskLogScheduler.java
New file
@@ -0,0 +1,77 @@
package com.zy.asrs.task;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.exception.CoolException;
import com.zy.asrs.domain.enums.TaskStatusType;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.TaskWrk;
import com.zy.asrs.entity.TaskWrkLog;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.TaskWrkLogService;
import com.zy.asrs.service.TaskWrkService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.List;
@Slf4j
@Component
public class AgvTaskLogScheduler {
    @Autowired
    private TaskWrkService taskWrkService;
    @Autowired
    private TaskWrkLogService taskWrkLogService;
    @Autowired
    private LocMastService locMastService;
    /**
     * AGV任务转历史
     */
    @Scheduled(cron = "0/3 * * * * ? ")
    public void execute() {
        List<TaskWrk> taskWrkList = taskWrkService.selectList(new EntityWrapper<TaskWrk>()
                .eq("status", TaskStatusType.COMPLETE.id));
        for (TaskWrk taskWrk : taskWrkList) {
            Date now = new Date();
            String originPoint = taskWrk.getStartPoint();
            String targetPoint = taskWrk.getTargetPoint();
            LocMast startLocMast = locMastService.selectByLocNo(originPoint);
            if(startLocMast == null){
                throw new CoolException("取货点库位不存在");
            }
            if (!startLocMast.getLocSts().equals("R")) {
                throw new CoolException("取货点不处于出库预约");
            }
            LocMast targetLocMast = locMastService.selectByLocNo(targetPoint);
            if(targetLocMast == null){
                throw new CoolException("放货点库位不存在");
            }
            if (!targetLocMast.getLocSts().equals("S")) {
                throw new CoolException("放货点不处于入库预约");
            }
            startLocMast.setLocSts("O");
            startLocMast.setModiTime(now);
            locMastService.updateById(startLocMast);
            targetLocMast.setLocSts("F");
            targetLocMast.setModiTime(now);
            locMastService.updateById(targetLocMast);
            TaskWrkLog taskWrkLog = new TaskWrkLog(taskWrk);
            if (!taskWrkLogService.insert(taskWrkLog)) {
                throw new CoolException("转历史档失败" + taskWrkLog);
            }
            if (!taskWrkService.deleteById(taskWrk)) {
                throw new CoolException("任务档删除失败" + taskWrkLog);
            }
        }
    }
}
src/main/java/com/zy/asrs/task/AssignAgvTaskScheduler.java
New file
@@ -0,0 +1,115 @@
package com.zy.asrs.task;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.zy.asrs.domain.enums.TaskStatusType;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.TaskWrk;
import com.zy.asrs.service.ApiLogService;
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.TaskWrkService;
import com.zy.common.utils.HttpHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@Slf4j
@Component
public class AssignAgvTaskScheduler {
    @Autowired
    private TaskWrkService taskWrkService;
    @Autowired
    private ApiLogService apiLogService;
    @Autowired
    private LocMastService locMastService;
    @Value("${agv.url}")
    private String agvUrl;
    @Value("${agv.applyTask}")
    private String agvApplyTask;
    /**
     * 自动派发AGV搬运任务
     */
    @Scheduled(cron = "0/3 * * * * ? ")
    public void execute() {
        List<TaskWrk> taskWrks = taskWrkService.selectList(new EntityWrapper<TaskWrk>()
                .eq("status", TaskStatusType.RECEIVE.id).eq("io_type", 4));
        for (TaskWrk taskWrk : taskWrks) {
            String startPoint = taskWrk.getStartPoint();
            String targetPoint = taskWrk.getTargetPoint();
            LocMast startLocMast = locMastService.selectByLocNo(startPoint);
            if(startLocMast == null){
                continue;
            }
            if (!startLocMast.getLocSts().equals("R")) {
                continue;
            }
            LocMast targetLocMast = locMastService.selectByLocNo(targetPoint);
            if(targetLocMast == null){
                continue;
            }
            if (!targetLocMast.getLocSts().equals("S")) {
                continue;
            }
            HashMap<String, Object> requestParam = new HashMap<>();
            requestParam.put("reqCode", taskWrk.getTaskNo());
            requestParam.put("taskCode", taskWrk.getTaskNo());
            requestParam.put("taskTyp", "YK");
            ArrayList<HashMap<String, Object>> positionCodePathList = new ArrayList<>();
            HashMap<String, Object> startPointParam = new HashMap<>();
            startPointParam.put("positionCode", taskWrk.getStartPoint());
            startPointParam.put("type", "00");
            HashMap<String, Object> targetPointParam = new HashMap<>();
            targetPointParam.put("positionCode", taskWrk.getTargetPoint());
            targetPointParam.put("type", "00");
            positionCodePathList.add(startPointParam);
            positionCodePathList.add(targetPointParam);
            requestParam.put("positionCodePath", positionCodePathList);
            String response = null;
            boolean requestStatus = false;
            try {
                log.info("WCS派发任务给AGV={}", taskWrk);
                response = new HttpHandler.Builder()
                        .setUri(agvUrl)
                        .setPath(agvApplyTask)
                        .setJson(JSON.toJSONString(requestParam))
                        .build()
                        .doPost();
                JSONObject jsonObject = JSON.parseObject(response);
                if (jsonObject.get("code").equals("0")) {
                    taskWrk.setStatus(TaskStatusType.DISTRIBUTE.id);
                    taskWrkService.updateById(taskWrk);
                    requestStatus = true;
                }
            } catch (Exception e) {
                log.error("WCS派发任务给AGV失败{},返回值={}", taskWrk, response);
            } finally {
                apiLogService.save("WCS派发任务给AGV"
                        , agvUrl + agvApplyTask
                        , null
                        , "127.0.0.1"
                        , JSON.toJSONString(requestParam)
                        , response
                        , requestStatus
                );
            }
        }
    }
}
src/main/java/com/zy/core/MainProcess.java
@@ -43,30 +43,13 @@
                        continue;
                    }
                    // 演示
//                    mainService.crnDemoOfLocMove1();
                    // 入库  ===>> 入库站到堆垛机站,根据条码扫描生成入库工作档
                    mainService.generateStoreWrkFile1(); // 组托
                    // 入出库  ===>>  调用RCS进行入出库
                    mainService.crnIoExecute();
                    // 出库  ===>>  堆垛机出库站到出库站
                    mainService.crnStnToOutStn();
                    // 入库  ===>> 执行对工作档的完成操作
//                    mainService.storeFinished();
                    // 堆垛机异常信息记录
//                    mainService.recCrnErr();
                    // 入库  ===>> 空栈板初始化入库,叉车入库站放货
//                    mainService.storeEmptyPlt();
//                    mainService.outOfDevp();
                    // 其他  ===>> // 入出库模式切换函数
                    i++;
                    if (i > 1) {
//                        mainService.ioConvert();
                        i = 0;
                    }
                    //演示模式
                    mainService.demo();
                    //自动派发任务
   //                 mainService.autoDistribute();
src/main/java/com/zy/core/thread/SiemensDevpThread.java
@@ -322,15 +322,17 @@
            //外形检测
            OperateResultExOne<byte[]> resultErr1 = siemensS7Net.Read("DB101.810.0", (short) (barcodeSize*1));
            StaProtocol staProtocol1 = station.get(116);
            boolean[] status1 = siemensS7Net.getByteTransform().TransBool(resultErr1.Content, 0, 1);
            staProtocol1.setFrontErr(status1[0]);
            staProtocol1.setBackErr(status1[1]);
            staProtocol1.setHighErr(status1[2]);
            staProtocol1.setLeftErr(status1[3]);
            staProtocol1.setRightErr(status1[4]);
            staProtocol1.setWeightErr(status1[5]);
            staProtocol1.setBarcodeErr(status1[6]);
            if (resultErr1.IsSuccess) {
                StaProtocol staProtocol1 = station.get(116);
                boolean[] status1 = siemensS7Net.getByteTransform().TransBool(resultErr1.Content, 0, 1);
                staProtocol1.setFrontErr(status1[0]);
                staProtocol1.setBackErr(status1[1]);
                staProtocol1.setHighErr(status1[2]);
                staProtocol1.setLeftErr(status1[3]);
                staProtocol1.setRightErr(status1[4]);
                staProtocol1.setWeightErr(status1[5]);
                staProtocol1.setBarcodeErr(status1[6]);
            }
            OperateResultExOne<byte[]> resultErr = siemensS7Net.Read("DB101.922.0", (short) (staNoSize * 4));
            if (resultErr.IsSuccess) {
src/main/resources/application.yml
@@ -37,7 +37,7 @@
#License相关配置
license:
  subject: lfdwcs_sxc
  subject: tswcs_sxk
  publicAlias: publicCert
  storePass: public_zhongyang_123456789
  licensePath: license.lic
@@ -69,3 +69,7 @@
  outboundTaskRequest : openapi/createOutTask
  # 移库申请接口
  movePathWcs: openapi/createLocMoveTask
agv:
  url: 10.10.20.160:8181
  applyTask: /rcms/services/rest/hikRpcService/genAgvSchedulingTask
src/main/resources/license.lic
Binary files differ
src/main/resources/sql/tswcs_sxk.bak
Binary files differ