侧面出库完成上报执行状态替代plc码盘完成信号交互

pang.jiabao

4 天以前 3b17ccf3fd001cbec7a8bac368f07cd9237faae8

 src/main/java/com/zy/asrs/task/TaskReportScheduler.java

@@ -4,24 +4,41 @@
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.exception.CoolException;
import com.zy.asrs.domain.enums.TaskStatusType;
import com.zy.asrs.domain.enums.WorkNoType;
import com.zy.asrs.entity.LocMast;
import com.zy.asrs.entity.TaskWrk;
import com.zy.asrs.entity.TaskWrkReport;
import com.zy.asrs.entity.TaskWrkReportLog;
import com.zy.asrs.entity.param.TaskCreateParam;
import com.zy.asrs.entity.wms.WmsFeedback;
import com.zy.asrs.service.ApiLogService;
import com.zy.asrs.service.TaskWrkReportLogService;
import com.zy.asrs.service.TaskWrkReportService;
import com.zy.asrs.mapper.TaskWrkMapper;
import com.zy.asrs.service.*;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
import com.zy.common.utils.Synchro;
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.Task;
import com.zy.core.model.protocol.StaProtocol;
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 org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 定时将任务(完成、取消)转成日志
@@ -46,16 +63,152 @@
    @Value("${wms.taskExecCallback}")
    private String TaskExecCallback;

    @Value("${wms.completeDevpTask}")
    private String completeDevpTask;

    @Scheduled(cron = "0/3 * * * * ? ")
    public void execute() throws IOException {
        Page<TaskWrkReport> taskWrkReportPage = taskWrkReportService.selectPage(new Page<>(0, 100), new EntityWrapper<TaskWrkReport>().orderBy("createTime", true));
    @Value("${wms.reportPalletizingCompleted}")
    private String reportPalletizingCompleted;

    @Resource
    private TaskWrkMapper taskWrkMapper;

    @Resource
    private LocMastService locMastService;

    @Resource
    private CommonService commonService;

    @Resource
    private OpenService openService;

    // 监听外置输送线
    public static final ArrayList<Integer> staNos = new ArrayList<Integer>() {{
        add(301);add(302);add(303);add(304);add(305);add(306);add(307);add(308);
    }};

    // 侧面码盘完成上报wms -弃用，出库完成时候上报状态
//    @Scheduled(cron = "0/3 * * * * ? ")
    public synchronized void reportPalletizingCompleted() {
        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        if (devpThread != null) {
            Map<Integer, StaProtocol> staProtocolMap = devpThread.getStation();
            int[] siteArray = new int[]{203, 207, 212};
            for (int site : siteArray) {
                StaProtocol staProtocol = staProtocolMap.get(site);
                if (staProtocol != null) {
                    short mpCompletedFlag = staProtocol.getMpCompletedFlag();
                    if (mpCompletedFlag == 1) {
                        TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(staProtocol.getWorkNo()));
                        if (taskWrk != null && taskWrk.getMp() == 1 && taskWrk.getMpCompletedReport() == 0) {

                            // 请求体
                            JSONObject request = new JSONObject();
                            request.put("site", site);

                            String response = "";
                            boolean bool = false;
                            try {
                                response = new HttpHandler.Builder()
                                        // .setHeaders(headParam)
                                        .setUri(wmsUrl)
                                        .setPath(reportPalletizingCompleted)
                                        .setJson(JSON.toJSONString(request))
                                        .build()
                                        .doPost();
                                if (!Cools.isEmpty(response)) {
                                    JSONObject jsonObject = JSON.parseObject(response);
                                    if (Integer.parseInt(String.valueOf(jsonObject.get("code"))) == 200) {
                                        bool = true;
                                        // 推送队列
                                        boolean offer = MessageQueue.offer(SlaveType.Devp, 4, new Task(1, staProtocol));
                                        if (offer) {
                                            // 更新数据库
                                            taskWrk.setMpCompletedReport(1);
                                            taskWrkMapper.updateById(taskWrk);
                                        } else {
                                            log.error("侧面码盘完成上报wms推送队列失败，站点：{}，任务号：{}", site, staProtocol.getWorkNo());
                                        }
                                    }
                                }
                            } catch (Exception e) {
                                log.error("侧面码盘完成上报wms失败{},返回值={}", taskWrk, response);
                            } finally {
                                apiLogService.save("侧面码盘完成上报wms"
                                        , wmsUrl + reportPalletizingCompleted
                                        , null
                                        , "127.0.0.1"
                                        , JSON.toJSONString(request)
                                        , response
                                        , bool
                                );
                            }
                        }
                    }
                }
            }
        }
    }

    // WMS分配入库库位异常上报
    @Scheduled(cron = "0/5 * * * * ? ")
    @Transactional
    public synchronized void locationAssignmentExceptionEscalation() {
        List<TaskWrk> taskWrkList = taskWrkMapper.selectList(new EntityWrapper<TaskWrk>().eq("wrk_sts", 5));

        for(TaskWrk taskWrk : taskWrkList) {
            Date now = new Date();
            WmsFeedback wmsFeedback = new WmsFeedback();
            wmsFeedback.setTaskNo(taskWrk.getTaskNo());
            wmsFeedback.setIoType(taskWrk.getIoType());
            wmsFeedback.setBarcode(taskWrk.getBarcode());
            wmsFeedback.setStatus(-1); // 入库库位分配异常
            wmsFeedback.setReportTime(DateUtils.convert(now));

            String response = "";
            boolean bool = false;
            try {
                log.info("入库wms分配库位有误上报wms={}", taskWrk);
                response = new HttpHandler.Builder()
                        // .setHeaders(headParam)
                        .setUri(wmsUrl)
                        .setPath(TaskExecCallback)
                        .setJson(JSON.toJSONString(wmsFeedback))
                        .build()
                        .doPost();
                if (!Cools.isEmpty(response)) {
                    JSONObject jsonObject = JSON.parseObject(response);
                    if (Integer.parseInt(String.valueOf(jsonObject.get("code"))) == 200) {
                        bool = true;
                        taskWrk.setWrkSts(6);
                        taskWrk.setModiTime(now);
                        taskWrkMapper.updateById(taskWrk);
                    }
                }

            } catch (Exception e) {
                log.error("入库wms分配库位有误上报wms失败{},返回值={}", taskWrk, response);
            } finally {
                apiLogService.save("wms分配库位有误上报"
                        , wmsUrl + TaskExecCallback
                        , null
                        , "127.0.0.1"
                        , JSON.toJSONString(wmsFeedback)
                        , response
                        , bool
                );
            }
        }
    }

    @Scheduled(cron = "0/5 * * * * ? ")
    public synchronized void execute() throws IOException {
        Page<TaskWrkReport> taskWrkReportPage = taskWrkReportService.selectPage(new Page<>(0, 100), new EntityWrapper<TaskWrkReport>().orderBy("create_time", true));
        if (taskWrkReportPage.getRecords() != null) {
            //新增一个过滤机制
            for (TaskWrkReport taskWrk : taskWrkReportPage.getRecords()) {
                WmsFeedback wmsFeedback = getWmsFeedback(taskWrk);
                String response = "";
                Boolean bool = false;
                boolean bool = false;
                try {
                    log.info("wcs手动完成任务上报wms={}", taskWrk);
                    response = new HttpHandler.Builder()
@@ -65,17 +218,22 @@
                            .setJson(JSON.toJSONString(wmsFeedback))
                            .build()
                            .doPost();
                    JSONObject jsonObject = JSON.parseObject(response);
                    TaskWrkReportLog taskWrkLog = new TaskWrkReportLog();
                    Synchro.Copy(taskWrk, taskWrkLog);
                    taskWrkLog.setId(null);
                    if (!taskWrkReportLogService.insert(taskWrkLog)) {
                        throw new CoolException("转历史档失败" + taskWrkLog);
                    if (!Cools.isEmpty(response)) {
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (Integer.parseInt(String.valueOf(jsonObject.get("code"))) == 200) {
                            TaskWrkReportLog taskWrkLog = new TaskWrkReportLog();
                            Synchro.Copy(taskWrk, taskWrkLog);
                            taskWrkLog.setId(null);
                            if (!taskWrkReportLogService.insert(taskWrkLog)) {
                                throw new CoolException("转历史档失败" + taskWrkLog);
                            }
                            if (!taskWrkReportService.deleteById(taskWrk)) {
                                throw new CoolException("任务档删除失败" + taskWrkLog);
                            }
                            bool = true;
                        }
                    }
                    if (!taskWrkReportService.deleteById(taskWrk)) {
                        throw new CoolException("任务档删除失败" + taskWrkLog);
                    }
                    bool = true;

                } catch (Exception e) {
                    log.error("wcs手动完成任务上报wms失败{},返回值={}", taskWrk, response);
                } finally {
@@ -93,6 +251,135 @@

    }

    // 立体库跑库程序，生产勿用
//    @Scheduled(cron = "0/5 * * * * ? ")
    public synchronized void autoMoveLoc() {
        int flag = 1; // 1.跑23号堆垛机前7列，1号堆垛机1，9层 2.跑23号堆垛机后8-12列，1号堆垛机2-8层
        for(int i = 1; i <= 3; i++ ){
            // 获取堆垛机对应任务
            Integer count = taskWrkMapper.selectCount(new EntityWrapper<TaskWrk>().eq("crn_no", i));
            if (count == 0) {
                // 获取堆垛机巷道在库库位
                LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_sts", "F").eq("crn_no", i));
                if (locMast != null) {
                    // 50次出一次库
                    int count1 = locMastService.selectCount(new EntityWrapper<LocMast>().eq("crn_no", i).eq("status", 1));
                    if (count1 % 25 == 0) {
                        TaskCreateParam taskCreateParam = new TaskCreateParam();
                        taskCreateParam.setTaskNo(locMast.getLocNo()+"0");
                        taskCreateParam.setStartPoint(locMast.getLocNo());
                        taskCreateParam.setIoType(2);
                        taskCreateParam.setTaskPriority(11);
                        taskCreateParam.setBarcode(locMast.getBarcode());
                        taskCreateParam.setTargetPoint(i == 1 ? "114" : i == 2 ? "111" : "105");
                        openService.taskCreate(taskCreateParam);
                        return;
                    }
                    // 获取一个移动的目标库位
                    LocMast locMast1;
                    if (flag == 1) {
                        if (i == 1) {
                            locMast1 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("crn_no", i).eq("status", "0")
                                    .eq("loc_sts","O").orderBy("lev1").orderBy("bay1").orderBy("row1"));
                        } else if(i==2) {
                            locMast1 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("crn_no", i).eq("status", "0")
                                    .eq("loc_sts","O").orderBy("lev1").orderBy("bay1").orderBy("row1").gt("bay1",7));
                        }else {
                            locMast1 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("crn_no", i).eq("status", "0")
                                    .eq("loc_sts","O").orderBy("lev1").orderBy("bay1").orderBy("row1").gt("bay1",7));
                        }

                    } else {
                        if (i == 1) {
                            locMast1 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("crn_no", i).eq("status", "0")
                                    .eq("loc_sts","O").orderBy("lev1").orderBy("bay1").orderBy("row1").in("lev1",2,3,4,5,6,7,8));
                        } else {
                            locMast1 = locMastService.selectOne(new EntityWrapper<LocMast>().eq("crn_no", i).eq("status", "0")
                                    .eq("loc_sts","O").orderBy("lev1").orderBy("bay1").orderBy("row1").gt("bay1",7));
                        }

                    }

                    if (locMast1 != null) {
                        // 创建移库任务
                        TaskWrk taskWrk = new TaskWrk();
                        Date now = new Date();
                        taskWrk.setTaskNo(locMast1.getLocNo());//任务号
                        taskWrk.setWrkNo(commonService.getWorkNo(WorkNoType.PAKIN.type));
                        taskWrk.setStatus(TaskStatusType.RECEIVE.id);//任务状态：接收
                        taskWrk.setCreateTime(now);
                        taskWrk.setAssignTime(now);
                        taskWrk.setIoType(3);//任务类型
                        taskWrk.setIoPri(11);//优先级
                        taskWrk.setBarcode(locMast.getBarcode());//条码
                        taskWrk.setCrnNo(locMast.getCrnNo());
                        taskWrk.setWrkSts(11);
                        taskWrk.setStartPoint(locMast.getLocNo());//起点
                        taskWrk.setTargetPoint(locMast1.getLocNo());
                        taskWrkMapper.insert(taskWrk);
                        locMast1.setStatus("1");
                        locMastService.updateById(locMast1);
                    }
                }
            }
        }
    }

    // 监听外置输送线，有任务号和可出信号，上报成功清除任务号目标站
    @Scheduled(cron = "0/3 * * * * ? ")
    public synchronized void completeDevpTask() {
        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 2);
        if (devpThread != null) {
            for(Integer site : staNos) {
                StaProtocol staProtocol = devpThread.getStation().get(site);
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isOutEnable() && staProtocol.getWorkNo() != 0 && staProtocol.isAutoing() && staProtocol.isLoading()) {
                    String response = "";
                    boolean bool = false;
                    JSONObject request = new JSONObject();
                    request.put("site",site);
                    try {
                        log.info("外置输送线流动到位上报wms={}", site);
                        response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath(completeDevpTask)
                                .setJson(request.toJSONString())
                                .build()
                                .doPost();
                        if (!Cools.isEmpty(response)) {
                            JSONObject jsonObject = JSON.parseObject(response);
                            if (Integer.parseInt(String.valueOf(jsonObject.get("code"))) == 200) {
                                bool = true;
                                staProtocol.setWorkNo((short) 0);
                                staProtocol.setStaNo((short) 0);
                                boolean result = MessageQueue.offer(SlaveType.Devp, 2, new Task(2, staProtocol));
                                if (result) {
                                    log.info("外置输送线流动到位上报wms,清除输送线站点{}命令下发成功！",site);
                                } else {
                                    log.error("外置输送线流动到位上报wms,清除输送线站点{}命令下发失败！" ,site);
                                }
                            }
                        }
                    } catch (Exception e) {
                        log.error("外置输送线流动到位上报wms异常{},返回值={}", request, response);
                    } finally {
                        apiLogService.save("外置输送线流动到位上报wms"
                                , wmsUrl + completeDevpTask
                                , null
                                , "127.0.0.1"
                                , request.toJSONString()
                                , response
                                , bool
                        );
                    }
                }
            }
        }
    }

    private WmsFeedback getWmsFeedback(TaskWrkReport taskWrk) {
        WmsFeedback feedback = new WmsFeedback();