*

lsh

4 天以前 388353ed9bad250663e8ad8129463d1ea80d46e6

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

@@ -13,25 +13,24 @@
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.RgvStatusCache;
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.CrnCommand;
import com.zy.core.model.protocol.CrnProtocol;
import com.zy.core.model.protocol.RgvProtocol;
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 lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -42,6 +41,7 @@

import java.io.IOException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 立体仓库WCS系统主流程业务
@@ -80,6 +80,8 @@
    private CommonService commonService;
    @Autowired
    private CrnController crnController;
    @Autowired
    private BasDevpPositionService basDevpPositionService;

    @Value("${wms.url}")
    private String wmsUrl;
@@ -99,6 +101,9 @@

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

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

    public void generateStoreWrkFile() {
        try {
@@ -1106,25 +1111,63 @@
        return taskWrk;
    }

    public boolean deviceDetection(RgvSlave slave){
    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());
        if (rgvProtocol == null) {
        RgvTaskProtocol rgvTaskProtocol = RgvTaskCache.getRgvStatus(slave.getId());

        if (rgvProtocol == null || rgvTaskProtocol ==null) {
            return false;
        }
        if (!rgvProtocol.getModeType().equals(RgvModeType.AUTO) || rgvProtocol.getRgvPos().equals(0L)
        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)) {
            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){
@@ -1134,42 +1177,269 @@
        }
        if (rgvProtocolOther.statusEnable){
//            if (!rgvProtocolOther.getModeType().equals(RgvModeType.AUTO) || rgvProtocolOther.getRgvPos().equals(0L)) {
                return true;
            return true;
//            }
        }
        return false;
    }


    private void sc(){


        // 根据输送线plc遍历
        for (RgvSlave rgvSlave : slaveProperties.getRgv()) {
            if (!deviceDetection(rgvSlave)){
                continue;
            }
            RgvProtocol rgvProtocol = RgvStatusCache.getRgvStatus(rgvSlave.getId());

            RgvProtocol rgvProtocolOther = RgvStatusCache.getRgvStatus(rgvSlave.getOtherId());

            //求出当前车可运行范围
            Long[] farthestPoint = new Long[]{0L,0L};
            if (!rgvProtocolOther.statusEnable){
                farthestPoint = new Long[]{0L,0L};
            } else {
                if (rgvProtocolOther.getStatusType().equals(RgvStatusType.IDLE)){

                }
            }


            // 遍历入库口
            for (RgvSlave.RgvStn inSta : rgvSlave.getRgvInSStn()) {

            }
    public boolean deviceRgvDetection(Integer startSta,RgvSlave rgvSlave,Integer endSta){
        BasDevpPosition basDevpPositionStartSta = basDevpPositionService.selectOne(new EntityWrapper<BasDevpPosition>().eq("DEV_NO", startSta));
        if (basDevpPositionStartSta == null){
            return false;
        }

        BasDevpPosition basDevpPositionEndSta = basDevpPositionService.selectOne(new EntityWrapper<BasDevpPosition>().eq("DEV_NO", endSta));
        if (basDevpPositionEndSta == null){
            return false;
        }

        DevpThread devpThreadEnd = (DevpThread) SlaveConnection.get(SlaveType.Devp, basDevpPositionEndSta.getPlcId());
        StaProtocol staProtocolEnd = devpThreadEnd.getStation().get(endSta);
        if (staProtocolEnd == null){
            return false;
        }
        // 判断是否满足放货条件
        if (!staProtocolEnd.isAutoing() || staProtocolEnd.isLoading()) {
            return false;
        }

        if (!rgvDetection(rgvSlave)){
            return false;
        }

        //  a当前  b  other
        //  b可用
            //  b无任务
                    //  半边区域内全任务
                    //  半边区域内取货任务
                    //  半边区域内放货任务
                //切换B
                    //  半边区域内全任务
                    //  半边区域内取货任务
                    //  半边区域内放货任务
            //b 有任务
                //  可用区域任务
                //  可用区域任务内取货任务
                    //
         // b禁用
            // 全区域任务  就近取货


        return false;
    }

    public synchronized void taskStart() {
        for (RgvSlave rgvSlave : slaveProperties.getRgv()) {
            try{
                if (rgvDetection(rgvSlave)){
                    for (RgvSlave.RgvStn inSta : rgvSlave.getRgvInSta()){
                        TaskWrk taskWrk = deviceDetection(inSta);
                        if (taskWrk!=null){
                            if (deviceRgvDetection(inSta.getStaNo(),rgvSlave,taskWrk.getTargetPointConvert())){
                                RgvProtocol rgvStatus = RgvStatusCache.getRgvStatus(rgvSlave.getId());


                            }
                        }
                    }
                }
            } catch (Exception e){
                log.error("任务生成失败===》异常信息：{}",e.getMessage());
            }
        }
    }

    public synchronized void DevpTaskNoRun() {
        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 (rgvOtherStatusEnable(rgvSlave)){
                        //分成上下两部分任务
                        List<Integer>[] avoidRange = RouteUtils.avoidRange(staList, basDevpPositions);
                        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);
                        if (taskNoNow.equals("无")){ //b 无任务
                                //所属部分就进取货
                                //  半边区域内全任务
                            boolean sign = false;

                            for (Integer staNoNow : rangeList){
                                for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvInSta()){
                                    if (rgvStn.getStaNo().equals(staNoNow)){
                                        TaskWrk taskWrk = deviceDetection(rgvStn);
                                        if (taskWrk!=null){
                                            if ()
                                        }
                                    }
                                }
                            }
                            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)){

                                            break;
                                        }
                                    }
                                    if (sign){
                                        break;
                                    }
                                }
                            }
                            //切换B
                            continue;
                        } else {//b 有任务

                                //  可用区域任务
                                //  可用区域任务内取货任务
                                //切换B

                            continue;
                        }
                        break;
                    } else {
                        //可用区域就近取货
                    }
                }
            } 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;
    }



}