#

Junjie

2023-09-28 3909c3583e8fc2057715ca20ac16b14072f32b14

 src/main/java/com/zy/core/thread/NyShuttleThread.java

@@ -11,6 +11,7 @@
import com.zy.asrs.utils.Utils;
import com.zy.common.model.NavigateNode;
import com.zy.common.model.NyShuttleOperaResult;
import com.zy.common.service.CommonService;
import com.zy.common.utils.*;
import com.zy.core.News;
import com.zy.core.ThreadHandler;
@@ -28,6 +29,7 @@
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import javax.swing.*;
import java.io.IOException;
import java.net.Socket;
import java.text.MessageFormat;
@@ -67,10 +69,10 @@
                    case 1:
                        read();
                        break;
                    // 写入数据
                    case 2:
                        write((NyShuttleHttpCommand) task.getData());
                        break;
//                    // 写入数据
//                    case 2:
//                        write((NyShuttleHttpCommand) task.getData());
//                        break;
                    //下发任务
                    case 3:
                        assignWork((ShuttleAssignCommand) task.getData());
@@ -87,7 +89,7 @@

    private void read() {
        try {
            if (this.socket == null || !this.socket.isConnected()) {
            if (this.socket == null || this.socket.isClosed()) {
                //链接断开重新链接
                this.connect();
            }
@@ -95,9 +97,14 @@
            //四向穿梭车空闲、有任务、标记为true、存在任务指令，需要执行任务的下一条指令
            if (shuttleProtocol.getFree() == ShuttleStatusType.IDLE.id
                    && shuttleProtocol.getTaskNo() != 0
                    && shuttleProtocol.getPakMk()) {
                    && !shuttleProtocol.getPakMk()) {
                //执行下一步指令
                executeWork(shuttleProtocol.getTaskNo().shortValue());
            }

            //小车空闲且有跑库程序
            if (shuttleProtocol.isIdle() && shuttleProtocol.getMoveLoc()) {
                moveLoc();
            }
        } catch (Exception e) {
            e.printStackTrace();
@@ -117,7 +124,8 @@
            NyShuttleHttpCommand readStatusCommand = NyHttpUtils.getReadStatusCommand(slave.getId());
            JSONObject jsonObject = NyHttpUtils.requestCommand(socket, readStatusCommand);
            if (jsonObject == null) {
                OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.OFFLINE);
                OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车Socket状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            }else {
                //手动状态/自动状态
                shuttleProtocol.setWorkingMode(jsonObject.getInteger("workingMode"));
@@ -172,9 +180,9 @@
                //非自动状态时间计时
                shuttleProtocol.setErrTime(jsonObject.getInteger("errTime"));

                //小车处于运行中，将标记置为true
                //小车处于运行中，将标记置为false
                if (shuttleProtocol.getFree() == 0) {
                    shuttleProtocol.setPakMk(true);
                    shuttleProtocol.setPakMk(false);
                }

                //将四向穿梭车状态保存至数据库
@@ -243,7 +251,15 @@
            }
        } catch (Exception e) {
            e.printStackTrace();
            OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车Socket状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            try {
                this.socket.close();
                this.socket = null;
                Thread.sleep(1000);
                this.connect();
            } catch (IOException | InterruptedException exception) {
                e.printStackTrace();
            }
        }
    }

@@ -252,7 +268,9 @@
        try {
            Socket socket = new Socket(slave.getIp(),slave.getPort());
            socket.setSoTimeout(60000);
            socket.setKeepAlive(true);
            this.socket = socket;
            log.info(MessageFormat.format("【{0}】四向穿梭车Socket链接成功 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
        } catch (IOException e) {
            OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车Socket链接失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
        }
@@ -264,7 +282,7 @@

    }

    private boolean write(NyShuttleHttpCommand command){
    private boolean write(NyShuttleHttpCommand command, ShuttleAssignCommand assignCommand) {
        if (null == command) {
            News.error("四向穿梭车写入命令为空");
            return false;
@@ -282,11 +300,48 @@
        }

        //发出请求
        JSONObject result = NyHttpUtils.requestCommand(socket, command);
        JSONObject result = null;
        try {
            result = NyHttpUtils.requestCommand(socket, command);
        } catch (IOException e) {
            try {
                this.socket.close();
                this.socket = null;
                Thread.sleep(1000);
                this.connect();
            } catch (IOException exception) {
                exception.printStackTrace();
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            }
        }

        //保存数据到数据库做流水
        BasShuttleOptService shuttleOptService = SpringUtils.getBean(BasShuttleOptService.class);
        BasShuttleOpt opt = null;
        if (shuttleOptService != null) {
            opt = new BasShuttleOpt(
                    assignCommand.getTaskNo().intValue(),
                    assignCommand.getShuttleNo().intValue(),
                    new Date(),
                    ShuttleTaskModeType.get(assignCommand.getTaskMode()).desc,
                    assignCommand.getSourceLocNo(),
                    assignCommand.getLocNo(),
                    null,
                    null,
                    null,
                    JSON.toJSONString(command),
                    null,
                    JSON.toJSONString(shuttleProtocol)
            );
            opt.setSend(1);//已下发
            opt.setResponse(JSON.toJSONString(result));//请求响应
            shuttleOptService.insert(opt);
        }

        if (result == null) {
            return false;//请求失败
        }

        return true;
    }

@@ -330,116 +385,120 @@
        }

        NavigateMapData navigateMapData = new NavigateMapData(Utils.getLev(shuttleProtocol.getCurrentLocNo()));

        //取出命令
        NyShuttleHttpCommand command = commands.get(commandStep);//当前命令
//        if (commandStep != 0) {
//            //判断上一条指令是否完成
//            NyShuttleHttpCommand lastCommand = commands.get(commandStep - 1);
//            String requestType = lastCommand.getRequest().getBody().get("requestType").toString();
//            if (requestType.equals("move") || requestType.equals("intoLift") || requestType.equals("outLift")) {
//                //移动命令、出入提升机命令
//                NyShuttleProtocol.NyShuttlePointClass target = JSON.parseObject(lastCommand.getRequest().getBody().get("target").toString(), NyShuttleProtocol.NyShuttlePointClass.class);
//                if (shuttleProtocol.getPoint().equals(target)) {
//                    //上一条指令的目标位置和当前小车位置相同，则认定上一条任务完成
//                    lastCommand.setComplete(true);
//                    //解锁锁定路径，上一条路径和当前路径
//                    List<NavigateNode> nodes = lastCommand.getNodes();
//                    nodes.addAll(command.getNodes());
//                    navigateMapData.writeNavigateNodeToRedisMap(nodes, false);//解锁路径
//                }
//            }else {
//                lastCommand.setComplete(true);//其他命令默认认为完成
//            }
//            //任务数据保存到redis
//            redisUtil.set("shuttle_wrk_no_" + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));
//
//            if (!lastCommand.getComplete()) {
//                //上一条任务未完成，禁止下发命令
//                return false;
//            }
//        }
//
//        List<NavigateNode> nextNodes = null;//下一步命令行走路径
//        if (commandStep + 1 < commands.size()) {
//            NyShuttleHttpCommand nextCommand = commands.get(commandStep + 1);//下一步命令
//            nextNodes = nextCommand.getNodes();//下一步命令行走路径
//        }
//
//        if (shuttleProtocol.getFree() == ShuttleStatusType.BUSY.id) {
//            return false;//小车状态忙，禁止执行命令
//        }
//
        NyShuttleHttpCommand command = null;
        if (commandStep < commands.size()) {
            command = commands.get(commandStep);//当前命令
        }
        if (commandStep != 0) {
            //判断上一条指令是否完成
            NyShuttleHttpCommand lastCommand = commands.get(commandStep - 1);
            String requestType = lastCommand.getRequest().getBody().get("requestType").toString();
            if (requestType.equals("move") || requestType.equals("intoLift") || requestType.equals("outLift")) {
                //移动命令、出入提升机命令
                NyShuttleProtocol.NyShuttlePointClass target = JSON.parseObject(lastCommand.getRequest().getBody().get("target").toString(), NyShuttleProtocol.NyShuttlePointClass.class);
                if (shuttleProtocol.getPoint().equals(target)) {
                    //上一条指令的目标位置和当前小车位置相同，则认定上一条任务完成
                    lastCommand.setComplete(true);
                    //解锁锁定路径，上一条路径和当前路径
                    List<NavigateNode> nodes = lastCommand.getNodes();
                    if (command != null && command.getNodes() != null) {
                        nodes.addAll(command.getNodes());
                    }
                    if (nodes != null) {
                        navigateMapData.writeNavigateNodeToRedisMap(nodes, false);//解锁路径
                    }
                }
            }else {
                lastCommand.setComplete(true);//其他命令默认认为完成
            }
            //任务数据保存到redis
            redisUtil.set("shuttle_wrk_no_" + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));

            if (!lastCommand.getComplete()) {
                //上一条任务未完成，禁止下发命令
                return false;
            }

            //判断是否为最后一条命令且命令执行完成，抛出等待确认状态
            NyShuttleHttpCommand endCommand = commands.get(commands.size() - 1);
            if (endCommand.getComplete()) {
                //删除redis
                redisUtil.del("shuttle_wrk_no_" + redisCommand.getWrkNo());

                if (!assignCommand.getCharge()) {
                    //对主线程抛出等待确认状态waiting
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WAITING);
                }else {
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
                }
                News.info("四向穿梭车任务执行下发完成等待执行结束，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(commands));

                return false;//禁止再下发命令
            }
        }

        List<NavigateNode> nextNodes = null;//下一步命令行走路径
        if (commandStep + 1 < commands.size()) {
            NyShuttleHttpCommand nextCommand = commands.get(commandStep + 1);//下一步命令
            nextNodes = nextCommand.getNodes();//下一步命令行走路径
        }

        if (shuttleProtocol.getFree() == ShuttleStatusType.BUSY.id) {
            //停止充电
            if(!(command.getRequest().getBody().get("requestType").equals("stopCharge") && shuttleProtocol.getChargState() == 1)){
                return false;//小车状态忙，禁止执行命令
            }
        }

//        //检测小车是否要进提升机，如需要进提升机则调度提升机
//        if (!checkLiftStation(wrkNo)) {
//            return false;
//        }
//
//        //检测穿梭车是否在提升机内
//        if (!checkShuttleInTheLift(wrkNo)) {
//            return false;
//        }
//
//        //检测路径是否可行走
//        if (!checkPath(command.getNodes(), nextNodes, redisCommand)) {
//            return false;
//        }
//
//        //锁定路径，锁定当前路径和下一步路径
//        List<NavigateNode> nodes = command.getNodes();
//        nodes.addAll(nextNodes);
//        navigateMapData.writeNavigateNodeToRedisMap(nodes, true);//所使用的路径进行锁定禁用

        //检测穿梭车是否在提升机内
        if (!checkShuttleInTheLift(wrkNo)) {
            return false;
        }

        if (command.getRequest().getBody().get("requestType").equals("move")) {
            //检测路径是否可行走
            if (!checkPath(command.getNodes(), nextNodes, redisCommand)) {
                return false;
            }

            //锁定路径，锁定当前路径和下一步路径
            List<NavigateNode> nodes = command.getNodes();
            if (nextNodes != null) {
                nodes.addAll(nextNodes);
            }
            if (nodes != null) {
                navigateMapData.writeNavigateNodeToRedisMap(nodes, true);//所使用的路径进行锁定禁用
            }
        }

        //可执行命令
        if (!write(command)) {
        if (!write(command, assignCommand)) {
            News.error("四向穿梭车命令下发失败，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
            return false;
        }

        News.info("四向穿梭车命令下发成功，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
        //将标记置为false(防止重发)
        shuttleProtocol.setPakMk(false);
        shuttleProtocol.setPakMk(true);

        //保存数据到数据库做流水
        BasShuttleOptService shuttleOptService = SpringUtils.getBean(BasShuttleOptService.class);
        if (shuttleOptService != null) {
            BasShuttleOpt opt = new BasShuttleOpt(
                    assignCommand.getTaskNo().intValue(),
                    assignCommand.getShuttleNo().intValue(),
                    new Date(),
                    ShuttleTaskModeType.get(assignCommand.getTaskMode()).desc,
                    assignCommand.getSourceLocNo(),
                    assignCommand.getLocNo(),
                    null,
                    null,
                    null,
                    JSON.toJSONString(command),
                    null
            );
            shuttleOptService.insert(opt);
        String requestType = command.getRequest().getBody().get("requestType").toString();
        if (requestType.equals("updateFloor")) {
            //更新楼层命令
            shuttleProtocol.setPakMk(false);//恢复标记
        }

        //判断数据是否执行完成
        if (commandStep < commands.size() - 1) {
            //更新redis数据
            //步序增加
            commandStep++;
            redisCommand.setCommandStep(commandStep);
            //任务数据保存到redis
            redisUtil.set("shuttle_wrk_no_" + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));
        }else {
            //已执行完成

            //删除redis
            redisUtil.del("shuttle_wrk_no_" + redisCommand.getWrkNo());

            if (!assignCommand.getCharge()) {
                //对主线程抛出等待确认状态waiting
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WAITING);
            }else {
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
            }
            News.info("四向穿梭车任务执行下发完成等待执行结束，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
        }
        commandStep++;
        //更新redis数据
        redisCommand.setCommandStep(commandStep);
        //任务数据保存到redis
        redisUtil.set("shuttle_wrk_no_" + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));

        return true;
    }
@@ -547,7 +606,9 @@
            if (basLift == null) {
                continue;
            }
            if (basLift.getPoint().equals(shuttleProtocol.getPoint())) {
            Integer liftX = basLift.getPoint$().getX();
            Integer liftY = basLift.getPoint$().getY();
            if (liftX.equals(shuttleProtocol.getPoint().getX()) && liftY.equals(shuttleProtocol.getPoint().getY())) {
                //小车在提升机内
                //判断提升机是否空闲
                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
@@ -562,6 +623,8 @@
                    //提升机处于空闲，放行
                    return true;
                }
            }else {
                return true;//不在提升机内，放行
            }
        }
        return false;//默认不放行
@@ -575,46 +638,105 @@
        //检测路径是否可行走(检查路径锁定状态，检测路径是否有其他小车)
        //检测当前行走路径，和下一步路径
        boolean checkPathIsAvailable = NavigateUtils.checkPathIsAvailable(currentNodes, shuttleProtocol.getShuttleNo().intValue(), Utils.getLev(shuttleProtocol.getCurrentLocNo()));
        boolean checkPathIsAvailable2 = NavigateUtils.checkPathIsAvailable(nextNodes, shuttleProtocol.getShuttleNo().intValue(), Utils.getLev(shuttleProtocol.getCurrentLocNo()));
        if (checkPathIsAvailable && checkPathIsAvailable2) {
            return true;//可行走
        if (nextNodes == null) {
            if (checkPathIsAvailable) {
                return true;//可行走
            }
            return false;
        }else {
            boolean checkPathIsAvailable2 = NavigateUtils.checkPathIsAvailable(nextNodes, shuttleProtocol.getShuttleNo().intValue(), Utils.getLev(shuttleProtocol.getCurrentLocNo()));
            if (checkPathIsAvailable && checkPathIsAvailable2) {
                return true;//可行走
            }
        }

        ShuttleAssignCommand assignCommand = redisCommand.getAssignCommand();
        NavigateNode currentTarget = currentNodes.get(currentNodes.size() - 1);
        String currentLocNo = NavigatePositionConvert.nodeToLocNo(currentTarget);
        NavigateNode nextTarget = nextNodes.get(nextNodes.size() - 1);
        String nextLocNo = NavigatePositionConvert.nodeToLocNo(nextTarget);
        if (assignCommand.getLocNo().equals(currentLocNo) || assignCommand.getLocNo().equals(nextLocNo)) {
            //当前路径最后一个节点是目标库位，进行路径检测，如果不可行走，重新计算路径
            //不可行走，重新计算路径
            NyShuttleOperaResult result = NyShuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getShuttleNo().intValue(), shuttleProtocol.getTaskNo(), shuttleProtocol.getCurrentLocNo(), assignCommand.getLocNo());
            if (result == null) {
                return false;//路径计算失败，不可行走
            }

            List<NyShuttleHttpCommand> newCommands = result.getCommands();//新路径

            //当前步序
            int commandStep = redisCommand.getCommandStep();
            List<NyShuttleHttpCommand> commands = assignCommand.getCommands();

            commands.remove(commandStep);//移除当前步序指令
            if (assignCommand.getLocNo().equals(currentLocNo)) {
                //当前路径，需要再多移除下一步指令
                commands.remove(commandStep + 1);
            }

            //将新路径添加进指令集合
            commands.addAll(commandStep, newCommands);
            assignCommand.setCommands(commands);
            redisCommand.setAssignCommand(assignCommand);
            //任务数据保存到redis
            redisUtil.set("shuttle_wrk_no_" + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));
            return false;//当前不可行走，等待下一次执行走新路径
        }
//        ShuttleAssignCommand assignCommand = redisCommand.getAssignCommand();
//        NavigateNode currentTarget = currentNodes.get(currentNodes.size() - 1);
//        String currentLocNo = NavigatePositionConvert.nodeToLocNo(currentTarget);
//        NavigateNode nextTarget = nextNodes.get(nextNodes.size() - 1);
//        String nextLocNo = NavigatePositionConvert.nodeToLocNo(nextTarget);
//        if (assignCommand.getLocNo().equals(currentLocNo) || assignCommand.getLocNo().equals(nextLocNo)) {
//            //当前路径最后一个节点是目标库位，进行路径检测，如果不可行走，重新计算路径
//            //不可行走，重新计算路径
//            NyShuttleOperaResult result = NyShuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getShuttleNo().intValue(), shuttleProtocol.getTaskNo(), shuttleProtocol.getCurrentLocNo(), assignCommand.getLocNo());
//            if (result == null) {
//                return false;//路径计算失败，不可行走
//            }
//
//            List<NyShuttleHttpCommand> newCommands = result.getCommands();//新路径
//
//            //当前步序
//            int commandStep = redisCommand.getCommandStep();
//            List<NyShuttleHttpCommand> commands = assignCommand.getCommands();
//
//            commands.remove(commandStep);//移除当前步序指令
//            if (assignCommand.getLocNo().equals(currentLocNo)) {
//                //当前路径，需要再多移除下一步指令
//                commands.remove(commandStep + 1);
//            }
//
//            //将新路径添加进指令集合
//            commands.addAll(commandStep, newCommands);
//            assignCommand.setCommands(commands);
//            redisCommand.setAssignCommand(assignCommand);
//            //任务数据保存到redis
//            redisUtil.set("shuttle_wrk_no_" + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));
//            return false;//当前不可行走，等待下一次执行走新路径
//        }

        return false;//不可行走
    }

    /**
     * 跑库程序
     */
    private void moveLoc() {
        LocMastService locMastService = SpringUtils.getBean(LocMastService.class);
        ShuttleDispatchUtils shuttleDispatchUtils = SpringUtils.getBean(ShuttleDispatchUtils.class);
        CommonService commonService = SpringUtils.getBean(CommonService.class);
        WrkMastMapper wrkMastMapper = SpringUtils.getBean(WrkMastMapper.class);
        int lev = Utils.getLev(shuttleProtocol.getCurrentLocNo());//小车当前楼层
        if (!shuttleProtocol.isIdle()) {
            return;
        }

        WrkMast wrkMast = wrkMastMapper.selectShuttleHasMoveWorking(shuttleProtocol.getShuttleNo().intValue());
        if (wrkMast != null) {
            return;
        }

        if (shuttleProtocol.getMoveType() == 0) {//跑轨道
            ArrayList<String> locs = new ArrayList<>();
            for (int i = shuttleProtocol.getXCurrent(); i <= shuttleProtocol.getXTarget(); i++) {
                String locNo = Utils.getLocNo(i, shuttleProtocol.getYCurrent(), lev);
                locs.add(locNo);
            }
            List<LocMast> locMasts = locMastService.selectEmptyLocNos(locs);
            if (locMasts.isEmpty()) {
                //空库位
                shuttleProtocol.setYCurrent(shuttleProtocol.getYCurrent() + 1);
                return;
            }

            LocMast start = locMasts.get(0);
            LocMast target = locMasts.get(locMasts.size() - 1);
            //判断小车是否在起点位置
            if (!shuttleProtocol.getCurrentLocNo().equals(start.getLocNo())) {//不在起点位置，调度去起点位置
                shuttleDispatchUtils.dispatchShuttle(commonService.getWorkNo(3), start.getLocNo());
            }else {
                //在起点位置，调度去目标位置
                if (shuttleProtocol.getCurrentLocNo().equals(target.getLocNo())) {
                    shuttleProtocol.setYCurrent(shuttleProtocol.getYCurrent() + 1);//小车和目标位置一致，跳过
                }else {
                    boolean result = shuttleDispatchUtils.dispatchShuttle(commonService.getWorkNo(3), target.getLocNo());
                    if (result) {//调度成功
                        shuttleProtocol.setYCurrent(shuttleProtocol.getYCurrent() + 1);
                    }
                }
            }
        }else {//跑库位

        }
    }

}