*

lsh

2025-04-27 44be6da8fc2740a7e81d5b878a894e318b6a5f8c

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

@@ -4,39 +4,34 @@
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.TaskOverToWms;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.CommandUtils;
import com.zy.asrs.utils.RouteUtils;
import com.zy.asrs.utils.TrackRangeUtils;
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.cache.*;
import com.zy.core.enums.*;
import com.zy.core.model.CrnSlave;
import com.zy.core.model.DevpSlave;
import com.zy.core.model.RgvSlave;
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.model.protocol.*;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.BarcodeThread;
import com.zy.core.thread.RgvThread;
import com.zy.core.thread.SiemensDevpThread;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
@@ -45,11 +40,8 @@
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.lang.management.ThreadMXBean;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 立体仓库WCS系统主流程业务
@@ -80,31 +72,41 @@
    private TaskWrkService taskWrkService;
    @Autowired
    private StaDescMapper staDescMapper;

    @Autowired
    private StaDescService staDescService;

    @Autowired
    private ApiLogService apiLogService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private CrnController crnController;
    @Autowired
    private BasDevpPositionService basDevpPositionService;

    @Value("${wms.url}")
    private String wmsUrl;
    @Value("${wms.inboundTaskApplyPath}")
    private String inboundTaskApplyPath;
    @Value("${wms.movePath}")
    private String movePath;
    @Value("${wms.taskStatusFeedbackPath}")
    private String taskStatusFeedbackPath;
    @Autowired
    private CrnController crnController;

    @Value("${wms.rgvOpen}")
    private boolean rgvOpen;

    public void generateStoreWrkFile() throws IOException, InterruptedException {
    @Value("${constant-parameters.trackEntireLength}")
    private Long trackEntireLength;

    @Value("${constant-parameters.trackBenchmark}")
    private Long trackBenchmark;

    @Value("${constant-parameters.trackProportion}")
    private Long trackProportion;

    @Value("${constant-parameters.avoidDistance}")
    private Long avoidDistance;

    public void generateStoreWrkFile() {
        try {


            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                // 遍历入库口
@@ -117,8 +119,8 @@
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    Short workNo = staProtocol.getWorkNo();
                    Short stano = staProtocol.getStaNo();
                    Integer workNo = staProtocol.getWorkNo();
                    Integer stano = staProtocol.getStaNo();

                    // 尺寸检测异常
                    boolean back = false;
@@ -164,7 +166,7 @@
                        }
//                        News.warn("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);
                        staProtocol.setWorkNo(workNo);
                        staProtocol.setStaNo(inSta.getStaNo().shortValue());
                        staProtocol.setStaNo(inSta.getStaNo());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
@@ -199,8 +201,8 @@
                                        log.info("托盘码："+barcode+"任务档存在");
                                        return;
                                    }else {
                                        staProtocol.setWorkNo(taskWrk1.getWrkNo().shortValue());
                                        staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
                                        staProtocol.setWorkNo(taskWrk1.getWrkNo());
                                        staProtocol.setStaNo(staDesc.getCrnStn());
                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                    }
                                }
@@ -232,8 +234,8 @@
                                    // 退回
                                    log.error("扫码检测程序异常"+inSta.getStaNo()+"异常信息"+e1);
                                }
                                staProtocol.setWorkNo((short)9999);
                                staProtocol.setStaNo(inSta.getStaNo().shortValue());
                                staProtocol.setWorkNo(9999);
                                staProtocol.setStaNo(inSta.getStaNo());
                                devpThread.setPakMk(staProtocol.getSiteId(), false);
                                MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                                    TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
@@ -286,8 +288,8 @@
                                    log.error("扫码检测程序异常"+inSta.getStaNo()+errMsg);
                                    log.error("扫码检测程序异常,异常信息"+e);

                                    staProtocol.setWorkNo((short)9999);
                                    staProtocol.setStaNo(inSta.getStaNo().shortValue());
                                    staProtocol.setWorkNo(9999);
                                    staProtocol.setStaNo(inSta.getStaNo());
                                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
//                                    TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
@@ -341,8 +343,8 @@
                                        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());
                                        staProtocol.setWorkNo(taskWrk.getWrkNo());
                                        staProtocol.setStaNo(staDesc.getCrnStn());
                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                    }
                                }
@@ -355,8 +357,8 @@
                            // 退回
                            log.error("扫码入库失败，{}入库站因{}异常，托盘已被退回", inSta.getStaNo(), errMsg);

                            staProtocol.setWorkNo((short)9999);
                            staProtocol.setStaNo(inSta.getStaNo().shortValue());
                            staProtocol.setWorkNo(9999);
                            staProtocol.setStaNo(inSta.getStaNo());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            TaskWrk taskWrk = taskWrkMapper.selectByWrkNo(Integer.valueOf(workNo));
@@ -377,15 +379,33 @@
        }
    }


    /**
     * 堆垛机站出库到出库站
     */
    public void crnStnToOutStn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {

            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnSlave.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }
            BasCrnp basCrnp = basCrnpService.selectById(crnSlave.getId());
            if (basCrnp == null) {
                log.error("{}号堆垛机尚未在数据库进行维护！", crnSlave.getId());
                continue;
            }
            if (!crnSlave.getId().equals(crnProtocol.getLaneNo())){
                for (CrnSlave crnOther : slaveProperties.getCrn()) {
                    if (crnOther.getId().equals(crnProtocol.getLaneNo())){
                        crnSlave.updateCrnInStn(crnOther);
                    }
                }
            }
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
                List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnSlave.getId()).eq("crn_stn", crnStn.getStaNo()));

                List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("CRN_NO", crnSlave.getId()).eq("LANE_NO", crnProtocol.getLaneNo()).eq("CRN_STN", crnStn.getStaNo()));
//                List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnSlave.getId()).eq("").eq("crn_stn", crnStn.getStaNo()));
                for (StaDesc staDesc : staDescs){
                    try{
                        // 获取堆垛机出库站信息
@@ -398,14 +418,14 @@
                        }
                        if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == 0)) {
                            // 查询工作档
                            TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), staDesc.getStnNo().toString());
                            TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnProtocol.getLaneNo(), staDesc.getStnNo().toString());
                            if (taskWrk == null) {
                                continue;
                            }
                            log.info("下发输送线任务：taskWrk:"+JSON.toJSONString(taskWrk));
//                            R r = siteController.siteDetlUpdate(Integer.valueOf(taskWrk.getTargetPoint()), taskWrk.getWrkNo().shortValue(), (short) 0, "Y", false, false);
                            staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
                            staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
                            staProtocol.setWorkNo(taskWrk.getWrkNo());
                            staProtocol.setStaNo(staDesc.getCrnStn());
                            boolean offer = false;
                            try{
                                offer = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
@@ -451,6 +471,14 @@
                continue;
            }

            if (!crn.getId().equals(crnProtocol.getLaneNo())){
                for (CrnSlave crnOther : slaveProperties.getCrn()) {
                    if (crnOther.getId().equals(crnProtocol.getLaneNo())){
                        crn.updateCrnInStn(crnOther);
                    }
                }
            }

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

@@ -487,7 +515,7 @@
     */
    public void crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol) throws IOException {
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("CRN_NO", slave.getId()).eq("LANE_NO", crnProtocol.getLaneNo()).eq("CRN_STN", crnStn.getStaNo()));
            for (StaDesc staDesc : staDescs) {
                boolean flag = false;
                // 获取堆垛机入库站信息
@@ -513,7 +541,7 @@
                }

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

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

@@ -572,7 +600,8 @@

                // 命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(staDesc.getCrnNo()); // 堆垛机编号
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                crnCommand.setCrnNo(staDesc.getLaneNo()); // 堆垛机巷道编号
                crnCommand.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
@@ -633,15 +662,17 @@
     * 2022-06-09 TQS修改，查询工作档LIST，遍历下发，防止第一个任务堵塞出库
     */
    public void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
        List<TaskWrk> taskWrksInitial = taskWrkMapper.selectPakOut(slave.getId(), null);
        List<TaskWrk> taskWrksInitial = taskWrkMapper.selectPakOut(crnProtocol.getLaneNo(), null);
        if (taskWrksInitial.size()==0){
            return;
        }
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("CRN_NO", slave.getId()).eq("LANE_NO", crnProtocol.getLaneNo()).eq("CRN_STN", crnStn.getStaNo()));

//            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnProtocol.getLaneNo()).eq("crn_stn", crnStn.getStaNo()));
            for (StaDesc staDesc : staDescs){
                // 获取工作状态为11（生成出库ID）的出库工作档
                List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(slave.getId(),staDesc.getStnNo().toString());
                List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(crnProtocol.getLaneNo(),staDesc.getStnNo().toString());
                for (TaskWrk taskWrk : taskWrks){
                    if (taskWrk == null) {
                        continue;
@@ -678,12 +709,13 @@
                        }

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

                        CrnCommand command = new CrnCommand();
                        command.setCrnNo(taskWrk.getCrnNo()); // 堆垛机编号
                        command.setCrnNo(slave.getId()); // 堆垛机编号
                        command.setLaneNo(crnProtocol.getLaneNo()); // 堆垛机编号
                        command.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
                        command.setAckFinish((short) 0);  // 任务完成确认位
                        command.setTaskMode(CrnTaskModeType.PAKIN); // 任务模式
@@ -695,7 +727,7 @@
                        command.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                        command.setCommand((short)1);
                        if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, command),false)) {
                            log.error("堆垛机命令生成失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(command));
                            log.error("堆垛机命令生成失败，堆垛机号={}，巷道={}，任务数据={}",slave.getId(), taskWrk.getCrnNo(), JSON.toJSON(command));
                            throw new CoolException("堆垛机命令生成失败");
                        }else{
                            try{
@@ -752,11 +784,12 @@
    public 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));
            List<TaskWrk> taskWrks = taskWrkMapper.selectList(
                    new EntityWrapper<TaskWrk>()
                    .eq("CRN_NO",crnProtocol.getLaneNo())
                    .eq("WRK_STS",11)
                    .eq("IO_TYPE",3)
                    .orderBy("IO_PRI",false));
            for (TaskWrk taskWrk : taskWrks){

                // 双深库位且浅库位有货，则需先对浅库位进行库位移转
@@ -773,7 +806,7 @@
                }

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

@@ -794,6 +827,7 @@
                // 1.堆垛机开始移动
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                crnCommand.setLaneNo(crnProtocol.getLaneNo()); // 堆垛机编号
                crnCommand.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
@@ -861,12 +895,20 @@
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }

            if (!crn.getId().equals(crnProtocol.getLaneNo())){
                for (CrnSlave crnOther : slaveProperties.getCrn()) {
                    if (crnOther.getId().equals(crnProtocol.getLaneNo())){
                        crn.updateCrnInStn(crnOther);
                    }
                }
            }

            //  状态：等待确认 并且  任务完成位 = 1
            if (!Cools.isEmpty(crnProtocol.getTaskFinish()) && crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
                //获取入库待确认工作档
                TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crn.getId(),crnProtocol.getTaskNo().intValue());
                TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crnProtocol.getLaneNo(),crnProtocol.getTaskNo().intValue());
                if (Cools.isEmpty(taskWrk)&&crnProtocol.getTaskNo() !=999) {
                    log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                    log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，巷道号={}，工作号={}", crn.getId(),crnProtocol.getLaneNo(), crnProtocol.getTaskNo());
                    continue;
                }
                Thread.sleep(300);
@@ -1105,23 +1147,331 @@
            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;
    }

    public String rgvOtherTaskWrk(RgvSlave slave){

        RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, slave.getOtherId());
        TaskProtocolCache taskProtocolCache = rgvThread.getTaskProtocolCache();
        ConcurrentHashMap<String, TaskProtocol> allTaskProtocol = taskProtocolCache.getAllTaskProtocol();
        if (!allTaskProtocol.isEmpty()){
            for (TaskProtocol taskProtocol : allTaskProtocol.values()){
                if (taskProtocol.getTaskNo() != 0 ){
                    return taskProtocol.getTaskNo().toString();
                }
            }
        }
        return "无";

    }
    public boolean rgvDetection(RgvSlave slave){
        RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(slave.getId());
        RgvTaskProtocol rgvTaskProtocol = RgvTaskCache.getRgvStatus(slave.getId());

        if (rgvProtocol == null || rgvTaskProtocol ==null) {
            return false;
        }
        if (!rgvProtocol.getModeType().equals(RgvModeType.AUTO) || rgvProtocol.getRgvPos().equals(0L) || rgvTaskProtocol.getAvoid() == -1 || rgvProtocol.getRgvPosDestination() == 0L
                || (!rgvProtocol.getStatusType().equals(RgvStatusType.IDLE) && !rgvProtocol.getStatusType().equals(RgvStatusType.ROAM))) {
            return false;
        }
        RgvProtocol rgvProtocolOther = RgvStatusCache.getRgvStatus(slave.getOtherId());
        RgvTaskProtocol rgvTaskProtocolOther = RgvTaskCache.getRgvStatus(slave.getOtherId());

        if (rgvProtocolOther == null) {
            return false;
        }
        if (rgvProtocolOther.statusEnable){
            if (!rgvProtocolOther.getModeType().equals(RgvModeType.AUTO) || rgvProtocolOther.getRgvPos().equals(0L) || rgvTaskProtocolOther.getAvoid() == -1  || rgvProtocolOther.getRgvPosDestination() == 0L) {
                return false;
            }
        }
        return true;
    }

    public TaskWrk deviceDetection(RgvSlave.RgvStn inSta){

        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, inSta.getDevpPlcId());
        StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
        if (staProtocol == null){
            return null;
        }
        // 判断是否满足取货条件
        if (staProtocol.isAutoing()
//                && staProtocol.isLoading()
                && staProtocol.getWorkNo()!=0) {
            TaskWrk taskWrk = taskWrkService.selectByTaskNo(staProtocol.getWorkNo().toString());
            if (taskWrk!=null){
                return taskWrk;
            }
        }
        return null;
    }

    public boolean rgvOtherStatusEnable(RgvSlave slave){
        RgvProtocol rgvProtocolOther = RgvStatusCache.getRgvStatus(slave.getOtherId());
        if (rgvProtocolOther == null) {
            return true;
        }
        if (rgvProtocolOther.statusEnable){
//            if (!rgvProtocolOther.getModeType().equals(RgvModeType.AUTO) || rgvProtocolOther.getRgvPos().equals(0L)) {
            return true;
//            }
        }
        return false;
    }

    public synchronized void taskStart() {
        for (RgvSlave rgvSlave : slaveProperties.getRgv()) {
            try{
                if (rgvDetection(rgvSlave)){
                    String taskNoNow = rgvOtherTaskWrk(rgvSlave);
                    List<BasDevpPosition> basDevpPositions = basDevpPositionService.selectList(new EntityWrapper<BasDevpPosition>().orderBy("PLC_POSITION", true));
                    boolean itSmall = new TrackRangeUtils().IsItSmall(rgvSlave);
                    if (basDevpPositions.isEmpty()) {
                        log.error("获取所有站点信息异常");
                        continue;
                    }
                    List<TaskWrk> taskWrkList = new ArrayList<>();
                    List<Integer> staList = new ArrayList<>();
                    for (RgvSlave.RgvStn inSta : rgvSlave.getRgvInSta()){
                        TaskWrk taskWrk = deviceDetection(inSta);
                        if (taskWrk!=null){
                            if (taskWrk.getTaskNo().equals(taskNoNow)) continue;
                            taskWrkList.add(taskWrk);
                            staList.add(inSta.getStaNo());
                        }
                    }

                    if (taskWrkList.isEmpty() || staList.isEmpty()) continue;

                    boolean sign = false;

                    if (rgvOtherStatusEnable(rgvSlave)){
                        //分成上下两部分任务
                        List<Integer>[] avoidRange = RouteUtils.gradeRange(staList, basDevpPositions,itSmall);
                        List<Integer> rangeListSou = avoidRange[itSmall ? 0 : 1];
                        List<Integer> rangeListSouOther = avoidRange[itSmall ? 1 : 0];
                        //就近排序
                        RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(rgvSlave.getId());
                        List<Integer> rangeList = RouteUtils.SortNearby(rangeListSou, rgvProtocol.RgvPos, basDevpPositions);
                        List<Integer> rangeListOther = RouteUtils.SortNearby(rangeListSouOther, rgvProtocol.RgvPos, basDevpPositions);

                        //所属部分就进取货

                        //筛选范围内任务
                        //就近排序
                        //筛选在范围任务
                        Long[][] avoidedRange = new TrackRangeUtils().avoidRangeArr(rgvSlave, trackEntireLength, trackBenchmark, avoidDistance);
                        List<Integer> belongToRange = RouteUtils.SortNearby(RouteUtils.belongToRange(rangeList, avoidedRange[0], basDevpPositions), rgvProtocol.RgvPos, basDevpPositions);

                        for (Integer staNoNow : belongToRange){
                            for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                if (rgvStn.getStaNo().equals(staNoNow)){
                                    TaskWrk taskWrk = deviceDetection(rgvStn);
                                    if (taskWrk!=null){
                                        BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper<BasDevpPosition>().eq("DEV_NO", taskWrk.getTargetPointConvert()));
                                        if (RouteUtils.CheckIfItIsWithinTheRange(rangeList,basDevpPosition.getPlcPosition(),basDevpPositions,itSmall)){
                                            sign = taskGenerate(rgvSlave,rgvStn,0);
                                        }
                                    }
                                    break;
                                }
                            }
                            if (sign){
                                break;
                            }
                        }
                        if (!sign){
                            //  筛选范围内取货任务
                            for (Integer staNoNow : belongToRange){
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                    if (rgvStn.getStaNo().equals(staNoNow)){
                                        sign = taskGenerate(rgvSlave,rgvStn,0);
                                        break;
                                    }
                                }
                                if (sign){
                                    break;
                                }
                            }
                        }

                        if (!sign){
                            for (Integer staNoNow : rangeList){
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                    if (rgvStn.getStaNo().equals(staNoNow)){
                                        TaskWrk taskWrk = deviceDetection(rgvStn);
                                        if (taskWrk!=null){
                                            BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper<BasDevpPosition>().eq("DEV_NO", taskWrk.getTargetPointConvert()));
                                            if (RouteUtils.CheckIfItIsWithinTheRange(rangeList,basDevpPosition.getPlcPosition(),basDevpPositions,itSmall)){
                                                sign = taskGenerate(rgvSlave,rgvStn,0);
                                            }
                                        }
                                        break;
                                    }
                                }
                                if (sign){
                                    break;
                                }
                            }
                        }
                        if (!sign){
                            //  半边区域内取货任务
                            for (Integer staNoNow : rangeList){
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                    if (rgvStn.getStaNo().equals(staNoNow)){
                                        sign = taskGenerate(rgvSlave,rgvStn,0);
                                        break;
                                    }
                                }
                                if (sign){
                                    break;
                                }
                            }
                        }
                        if (!sign){
                            //  半边区域内放货任务
                            for (Integer staNoNow : rangeListOther){
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                    if (rgvStn.getStaNo().equals(staNoNow)){
                                        TaskWrk taskWrk = deviceDetection(rgvStn);
                                        if (taskWrk!=null){
                                            BasDevpPosition basDevpPosition = basDevpPositionService.selectOne(new EntityWrapper<BasDevpPosition>().eq("DEV_NO", taskWrk.getTargetPointConvert()));
                                            if (RouteUtils.CheckIfItIsWithinTheRange(rangeList,basDevpPosition.getPlcPosition(),basDevpPositions,itSmall)){
                                                sign = taskGenerate(rgvSlave,rgvStn,0);
                                            }
                                        }
                                        break;
                                    }
                                }
                                if (sign){
                                    break;
                                }
                            }
                        }
                    } else {
                        //可用区域就近取货
                        //就近排序
                        RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(rgvSlave.getId());
                        List<Integer> rangeList = RouteUtils.SortNearby(staList, rgvProtocol.RgvPos, basDevpPositions);
                        //  半边区域内取货任务
                        for (Integer staNoNow : rangeList){
                            for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                if (rgvStn.getStaNo().equals(staNoNow)){
                                    sign = taskGenerate(rgvSlave,rgvStn,0);
                                    break;
                                }
                            }
                            if (sign){
                                break;
                            }
                        }
                    }
                }
            } catch (Exception e){
                log.error("任务生成失败===》异常信息：{}",e.getMessage());
            }
        }
    }
    //获取起点与终点对象
    public RgvSlave.RgvStn getRgvStnNow(RgvSlave rgvSlave,Integer staNo) {
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
            if (rgvStn.getStaNo().equals(staNo)){
                return rgvStn;
            }
        }
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvOutSta()){
            if (rgvStn.getStaNo().equals(staNo)){
                return rgvStn;
            }
        }
        return null;
    }

    //获取起点与终点对象
    public RgvSlave.RgvStn[] getRgvStnAll(RgvSlave rgvSlave,Integer souSta,Integer endSta) {
        RgvSlave.RgvStn[] rgvStns = new RgvSlave.RgvStn[2];
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
            if (rgvStn.getStaNo().equals(souSta)){
                rgvStns[0] = rgvStn;
            }
        }
        for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvOutSta()){
            if (rgvStn.getStaNo().equals(endSta)){
                rgvStns[1] = rgvStn;
            }
        }
        return rgvStns;
    }

    public boolean taskGenerate(RgvSlave rgvSlave,RgvSlave.RgvStn rgvStn,Integer sign) {
        try{
            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgvSlave.getId());
            TaskProtocolCache taskProtocolCache = rgvThread.getTaskProtocolCache();

            TaskProtocol issuedTake = new TaskProtocol();
            TaskProtocol issuedPut = new TaskProtocol();
            try{
                ConcurrentHashMap<String, TaskProtocol> allTaskProtocol = taskProtocolCache.getAllTaskProtocol();
                if (allTaskProtocol.size() > 0){
                    return false;
                }
                TaskWrk taskWrk = deviceDetection(rgvStn);
                if (taskWrk == null){
                    return false;
                }
                Integer targetPointConvert = taskWrk.getTargetPointConvert();
                if (targetPointConvert == null){
                    return false;
                }
                RgvSlave.RgvStn rgvStnEnd = getRgvStnNow(rgvSlave, targetPointConvert);
                if (rgvStnEnd == null){
                    return false;
                }

                BasDevpPosition basDevpPositionSou = basDevpPositionService.selectOne(new EntityWrapper<BasDevpPosition>().eq("DEV_NO", rgvStn.getStaNo()));
                BasDevpPosition basDevpPositionEnd = basDevpPositionService.selectOne(new EntityWrapper<BasDevpPosition>().eq("DEV_NO", targetPointConvert));
                //执行
                issuedTake.setTaskNo(Long.valueOf(taskWrk.getTaskNo()));
                issuedTake.setTaskStatus(1);
                issuedTake.setTaskNoDirection(issuedTake.gettaskNoDirection$(issuedTake.getTaskNo(),issuedTake.getTaskStatus()));
                issuedTake.setTargetPosition(basDevpPositionSou.getPlcPosition());
                issuedTake.setIsRunning(1);
                issuedTake.setDirection(rgvStn.isDirection());


                issuedPut.setTaskNo(Long.valueOf(taskWrk.getTaskNo()));
                issuedPut.setTaskStatus(2);
                issuedPut.setTaskNoDirection(issuedPut.gettaskNoDirection$(issuedPut.getTaskNo(),issuedPut.getTaskStatus()));
                issuedPut.setTargetPosition(basDevpPositionEnd.getPlcPosition());
                issuedPut.setIsRunning(1);
                issuedPut.setDirection(rgvStnEnd.isDirection());
            }catch (Exception e){
                log.error("任务生成失败issued1===》异常信息：{}",e.getMessage());
                return false;
            }

            switch (sign){
                case 1:
                    taskProtocolCache.updateTaskProtocol(issuedTake);
                    break;
                case 2:
                    taskProtocolCache.updateTaskProtocol(issuedPut);
                    break;
                default:
                    taskProtocolCache.updateTaskProtocol(issuedTake);
                    taskProtocolCache.updateTaskProtocol(issuedPut);
                    break;
            }
        } catch (Exception e){
            log.error("任务生成失败issued2===》异常信息：{}",e.getMessage());
        }
        return true;
    }



}