#

zy

2025-08-03 d3417407db947cf6f10c163d75325fd7df408eab

#

 src/main/java/com/zy/core/ServerBootstrap.java

@@ -6,9 +6,11 @@
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.SlaveType;
import com.zy.core.properties.DeviceConfig;
import com.zy.core.thread.fake.FakeNyLiftThread;
import com.zy.core.thread.fake.FakeNyShuttleThread;
import com.zy.core.thread.fake.FakeZyForkLiftThread;
import com.zy.core.thread.impl.LfdZyForkLiftMasterThread;
import com.zy.core.thread.impl.NyLiftThread;
import com.zy.core.thread.impl.NyShuttleThread;
import com.zy.core.utils.DeviceMsgUtils;
import lombok.extern.slf4j.Slf4j;
@@ -71,6 +73,8 @@
        for (DeviceConfig device : deviceConfigs) {
            if (device.getDeviceType().equals(String.valueOf(SlaveType.ForkLift))) {
                initForkLiftThread(device);
            } else if (device.getDeviceType().equals(String.valueOf(SlaveType.Lift))) {
                initLiftThread(device);
            } else if (device.getDeviceType().equals(String.valueOf(SlaveType.Shuttle))) {
                initShuttleThread(device);
            }
@@ -85,6 +89,10 @@
        ThreadHandler thread2 = new FakeZyForkLiftThread(redisUtil);
        new Thread(thread2).start();
        SlaveConnection.put(SlaveType.FakeThread, 2, thread2);

        ThreadHandler thread3 = new FakeNyLiftThread(redisUtil);
        new Thread(thread3).start();
        SlaveConnection.put(SlaveType.FakeThread, 3, thread3);
    }


@@ -104,6 +112,18 @@
        SlaveConnection.put(SlaveType.ForkLiftMaster, deviceConfig.getDeviceNo(), thread);
    }

    private void initLiftThread(DeviceConfig deviceConfig) {
        ThreadHandler thread = null;
        if (deviceConfig.getThreadImpl().equals("NyLiftThread")) {
            thread = new NyLiftThread(deviceConfig, redisUtil);
        } else {
            throw new CoolException("未知的线程实现");
        }

        new Thread(thread).start();
        SlaveConnection.put(SlaveType.Lift, deviceConfig.getDeviceNo(), thread);
    }

    private void initShuttleThread(DeviceConfig deviceConfig) {
        ThreadHandler thread = null;
        if (deviceConfig.getThreadImpl().equals("NyShuttleThread")) {

 src/main/java/com/zy/core/controller/OpenController.java

@@ -12,6 +12,7 @@
import com.zy.core.properties.DeviceConfig;
import com.zy.core.thread.FakeThread;
import com.zy.core.thread.ForkLiftThread;
import com.zy.core.thread.LiftThread;
import com.zy.core.thread.ShuttleThread;
import com.zy.core.utils.DeviceMsgUtils;
import com.zy.core.utils.FakeDeviceUtils;
@@ -52,7 +53,9 @@
        if (param.getDeviceType().equals(String.valueOf(SlaveType.Shuttle))) {
            fakeThread = (FakeThread) SlaveConnection.get(SlaveType.FakeThread, 1);
        } else if (param.getDeviceType().equals(String.valueOf(SlaveType.ForkLift))) {
            fakeThread = (FakeThread) SlaveConnection.get(SlaveType.FakeThread, 1);
            fakeThread = (FakeThread) SlaveConnection.get(SlaveType.FakeThread, 2);
        } else if (param.getDeviceType().equals(String.valueOf(SlaveType.Lift))) {
            fakeThread = (FakeThread) SlaveConnection.get(SlaveType.FakeThread, 3);
        }

        if (fakeThread == null) {
@@ -72,7 +75,9 @@
        if (param.getDeviceType().equals(String.valueOf(SlaveType.Shuttle))) {
            fakeThread = (FakeThread) SlaveConnection.get(SlaveType.FakeThread, 1);
        } else if (param.getDeviceType().equals(String.valueOf(SlaveType.ForkLift))) {
            fakeThread = (FakeThread) SlaveConnection.get(SlaveType.FakeThread, 1);
            fakeThread = (FakeThread) SlaveConnection.get(SlaveType.FakeThread, 2);
        } else if (param.getDeviceType().equals(String.valueOf(SlaveType.Lift))) {
            fakeThread = (FakeThread) SlaveConnection.get(SlaveType.FakeThread, 3);
        }

        if (fakeThread == null) {
@@ -93,10 +98,12 @@
    public R getFakeThreadStatusList() {
        FakeThread fakeThread1 = (FakeThread) SlaveConnection.get(SlaveType.FakeThread, 1);
        FakeThread fakeThread2 = (FakeThread) SlaveConnection.get(SlaveType.FakeThread, 2);
        FakeThread fakeThread3 = (FakeThread) SlaveConnection.get(SlaveType.FakeThread, 3);

        HashMap<String, Object> map = new HashMap<>();
        map.put("fakeNyShuttleStatusMap", fakeThread1.getFakeStatusMap());
        map.put("fakeZyForkLiftStatusMap", fakeThread2.getFakeStatusMap());
        map.put("fakeNyLiftStatusMap", fakeThread3.getFakeStatusMap());
        return R.ok().add(map);
    }

@@ -130,6 +137,12 @@
                    continue;
                }
                deviceList.add(forkLiftThread.getDeviceConfig());
            } else if (slaveType.equals(SlaveType.Lift)) {
                LiftThread liftThread = (LiftThread) SlaveConnection.get(slaveType, config.getDeviceNo());
                if(liftThread == null){
                    continue;
                }
                deviceList.add(liftThread.getDeviceConfig());
            }
        }


 src/main/java/com/zy/core/enums/RedisKeyType.java

@@ -5,13 +5,16 @@
    //设备消息KEY
    DEVICE_SHUTTLE_MSG_KEY_("deviceShuttleMsgKey_"),
    DEVICE_FORK_LIFT_MSG_KEY_("deviceForkLiftMsgKey_"),
    DEVICE_LIFT_MSG_KEY_("deviceLiftMsgKey_"),

    //设备指令消息KEY
    DEVICE_SHUTTLE_COMMAND_MSG_KEY("deviceShuttleCommandMsgKey_"),
    DEVICE_FORK_LIFT_COMMAND_MSG_KEY("deviceForkLiftCommandMsgKey_"),
    DEVICE_LIFT_COMMAND_MSG_KEY("deviceLiftCommandMsgKey_"),

    //虚拟设备指令消息KEY
    FAKE_DEVICE_FORK_LIFT_COMMAND_MSG_KEY("fakeDeviceForkLiftCommandMsgKey_"),
    FAKE_DEVICE_LIFT_COMMAND_MSG_KEY("fakeDeviceLiftCommandMsgKey_"),

    //设备配置文件
    DEVICE_CONFIG("deviceConfig"),

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

New file
@@ -0,0 +1,10 @@
package com.zy.core.thread;

import com.zy.core.ThreadHandler;
import com.zy.core.properties.DeviceConfig;

public interface LiftThread extends ThreadHandler {

    DeviceConfig getDeviceConfig();

}

 src/main/java/com/zy/core/thread/fake/FakeNyLiftThread.java

New file
@@ -0,0 +1,402 @@
package com.zy.core.thread.fake;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zy.common.Cools;
import com.zy.common.SpringUtils;
import com.zy.common.utils.RedisUtil;
import com.zy.core.News;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.RedisKeyType;
import com.zy.core.enums.SlaveType;
import com.zy.core.model.DeviceCommandMsgModel;
import com.zy.core.model.DeviceMsgModel;
import com.zy.core.model.param.UpdateFakeThreadStatusParam;
import com.zy.core.properties.DeviceConfig;
import com.zy.core.thread.FakeThread;
import com.zy.core.thread.impl.NyLiftThread;
import com.zy.core.utils.DeviceMsgUtils;
import com.zy.core.utils.FakeDeviceUtils;
import lombok.extern.slf4j.Slf4j;

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

@Slf4j
@SuppressWarnings("all")
public class FakeNyLiftThread implements FakeThread {

    private RedisUtil redisUtil;
    private JSONObject fakeStatusDemo = JSONObject.parseObject("{\"model\":2,\"plcTaskNo\":0,\"lev\":1,\"protocolStatus\":0,\"taskMode\":0,\"pick\":0,\"put\":0,\"iOMode\":0,\"errorCode\":0,\"hasTray\":0,\"hasCar\":0,\"trayList\":[0,0,0,0],\"carList\":[0,0,0,0],\"extend\":{\"frontOverrun\":false,\"backOverrun\":false,\"leftOverrun\":false,\"rightOverrun\":false,\"overHeight\":false,\"overWeight\":false}}");
    private ConcurrentHashMap<String, Thread> fakeThreadMap = new ConcurrentHashMap();
    private ConcurrentHashMap<String, JSONObject> fakeStatusMap = new ConcurrentHashMap();
    private ConcurrentHashMap<String, JSONObject> fakeCommandMap = new ConcurrentHashMap();

    private boolean fake = false;

    public FakeNyLiftThread(RedisUtil redisUtil) {
        this.redisUtil = redisUtil;
    }

    @Override
    public void run() {
        News.info("Fake Server is Started");

        Thread fakeCommandThread = new Thread(() -> {
            while (true) {
                try {
                    FakeDeviceUtils fakeDeviceUtils = null;
                    try {
                        fakeDeviceUtils = SpringUtils.getBean(FakeDeviceUtils.class);
                    }catch (Exception e){}
                    if(fakeDeviceUtils == null){
                        continue;
                    }
                    List<DeviceConfig> deviceConfigs = fakeDeviceUtils.getFakeDeviceConfig();
                    for (DeviceConfig device : deviceConfigs) {
                        excuteFakeCommand(String.valueOf(SlaveType.Lift) + device.getDeviceNo());
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        });
        fakeCommandThread.start();

        while (true) {
            try {
                initFakeDeviceServer();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    private synchronized void initFakeDeviceServer() {
        FakeDeviceUtils fakeDeviceUtils = null;
        try {
            fakeDeviceUtils = SpringUtils.getBean(FakeDeviceUtils.class);
        }catch (Exception e){}
        if(fakeDeviceUtils == null){
            return;
        }
        List<DeviceConfig> deviceConfigs = fakeDeviceUtils.getFakeDeviceConfig();
        for (DeviceConfig device : deviceConfigs) {
            if (!device.getDeviceType().equals(String.valueOf(SlaveType.Lift))) {
                continue;
            }

            if (!device.getThreadImpl().equals("NyLiftThread")) {
                continue;
            }

            if (fakeThreadMap.containsKey(String.valueOf(SlaveType.Lift) + device.getDeviceNo())) {
                continue;
            }

            Thread fakeThread = new Thread(() -> {
                log.info("{}:device is start handle client", device.getDeviceNo());
                try {
                    while (true) {
                        handleClient(device);
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            });
            fakeThread.start();

            String fakeStatus = JSON.toJSONString(fakeStatusDemo);
            if (!Cools.isEmpty(device.getFakeInitStatus())) {
                fakeStatus = device.getFakeInitStatus();
            }
            fakeThreadMap.put(String.valueOf(SlaveType.Lift) + device.getDeviceNo(), fakeThread);
            fakeStatusMap.put(String.valueOf(SlaveType.Lift) + device.getDeviceNo(), JSON.parseObject(fakeStatus));


            // init
            NyLiftThread thread = new NyLiftThread(device, redisUtil);;
            new Thread(thread).start();
            SlaveConnection.put(SlaveType.Lift, device.getDeviceNo(), thread);
        }
    }

    private void excuteFakeCommand(String key) {
        if (!fakeCommandMap.containsKey(key)) {
            return;
        }
        JSONObject command = fakeCommandMap.get(key);
        JSONObject commandBody = command.getJSONObject("commandBody");
        fakeCommandMap.remove(key);
        new Thread(() -> {
            try {
                JSONObject fakeStatus = fakeStatusMap.get(key);
                Integer commandType = command.getInteger("commandType");
                if (commandType == null) {
                    return;
                }

                if (commandType == 1) {
                    //取放货
                    fakeStatus.put("plcTaskNo", commandBody.getInteger("taskNo"));//任务号
                    fakeStatus.put("protocolStatus", 1);//取货中
                    fakeStatus.put("taskMode", commandType);//任务类型
                    fakeStatus.put("pick", commandBody.getInteger("pick"));//取货数据
                    fakeStatus.put("put", commandBody.getInteger("put"));//放货数据
                    fakeStatusMap.put(key, fakeStatus);

                    //delay
                    Thread.sleep(5000);

                    fakeStatus.put("protocolStatus", 0);
                    fakeStatus.put("taskMode", 0);//任务类型
                    fakeStatus.put("pick", 0);//取货数据
                    fakeStatus.put("put", 0);//放货数据
                    fakeStatus.put("lev", commandBody.getInteger("put"));
                    fakeStatusMap.put(key, fakeStatus);
                } else if (commandType == 2) {
                    //小车换层
                    fakeStatus.put("plcTaskNo", commandBody.getInteger("taskNo"));//任务号
                    fakeStatus.put("protocolStatus", 1);//取货中
                    fakeStatus.put("taskMode", commandType);//任务类型
                    fakeStatus.put("pick", commandBody.getInteger("pick"));//取货数据
                    fakeStatus.put("put", commandBody.getInteger("put"));//放货数据
                    fakeStatusMap.put(key, fakeStatus);

                    //delay
                    Thread.sleep(5000);

                    fakeStatus.put("protocolStatus", 0);
                    fakeStatus.put("taskMode", 0);//任务类型
                    fakeStatus.put("pick", 0);//取货数据
                    fakeStatus.put("put", 0);//放货数据
                    fakeStatus.put("lev", commandBody.getInteger("put"));
                    fakeStatusMap.put(key, fakeStatus);
                } else if (commandType == 3) {
                    //提升机移动
                    fakeStatus.put("plcTaskNo", commandBody.getInteger("taskNo"));//任务号
                    fakeStatus.put("protocolStatus", 1);//移动中
                    fakeStatus.put("taskMode", commandType);//任务类型
                    fakeStatus.put("pick", commandBody.getInteger("pick"));//取货数据
                    fakeStatus.put("put", commandBody.getInteger("put"));//放货数据
                    fakeStatusMap.put(key, fakeStatus);

                    //delay
                    Thread.sleep(5000);

                    fakeStatus.put("protocolStatus", 0);
                    fakeStatus.put("taskMode", 0);//任务类型
                    fakeStatus.put("pick", 0);//取货数据
                    fakeStatus.put("put", 0);//放货数据
                    fakeStatus.put("lev", commandBody.getInteger("put"));
                    fakeStatusMap.put(key, fakeStatus);
                } else if (commandType == 9996) {
                    //复位
                    fakeStatus.put("plcTaskNo", 0);//任务号
                    fakeStatus.put("protocolStatus", 0);
                    fakeStatus.put("taskMode", 0);//任务类型
                    fakeStatus.put("pick", 0);//取货数据
                    fakeStatus.put("put", 0);//放货数据
                    fakeStatusMap.put(key, fakeStatus);
                } else if (commandType == 9997) {
                    //切换入库模式
                    fakeStatus.put("iOMode", 1);//出入库模式
                    fakeStatusMap.put(key, fakeStatus);
                } else if (commandType == 9998) {
                    //切换出库模式
                    fakeStatus.put("iOMode", 2);//出入库模式
                    fakeStatusMap.put(key, fakeStatus);
                }

            }catch (Exception e){
                e.printStackTrace();
            }
        }).start();
    }

    private void handleClient(DeviceConfig device) throws IOException {
        try {
            Set<String> keys = redisUtil.searchKeys(RedisKeyType.FAKE_DEVICE_LIFT_COMMAND_MSG_KEY.key + device.getDeviceNo());
            if (keys.isEmpty()) {
                return;
            }

            TreeSet<String> treeSet = new TreeSet<>();
            for (String key : keys) {
                treeSet.add(key);
            }

            String first = treeSet.first();
            DeviceCommandMsgModel deviceCommandMsgModel = (DeviceCommandMsgModel) redisUtil.get(first);
            redisUtil.del(first);

//            log.info("收到Client Data: {}", JSON.toJSONString(result));
            processCommand(deviceCommandMsgModel, device);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void removeFake(DeviceConfig device) {
        Thread thread = fakeThreadMap.get(String.valueOf(SlaveType.Lift) + device.getDeviceNo());
        if (thread != null) {
            thread.interrupt();
        }

        fakeThreadMap.remove(String.valueOf(SlaveType.Lift) + device.getDeviceNo());
        fakeStatusMap.remove(String.valueOf(SlaveType.Lift) + device.getDeviceNo());
        fakeCommandMap.remove(String.valueOf(SlaveType.Lift) + device.getDeviceNo());
    }

    public void processCommand(DeviceCommandMsgModel deviceCommandMsgModel, DeviceConfig device) throws IOException {
        DeviceMsgUtils deviceMsgUtils = SpringUtils.getBean(DeviceMsgUtils.class);
        if (deviceMsgUtils == null) {
            return;
        }

        HashMap<String, Object> response = null;
        JSONObject fakeStatus = fakeStatusMap.get(String.valueOf(SlaveType.Lift) + device.getDeviceNo());

        String command = JSON.toJSONString(deviceCommandMsgModel.getCommand());
        JSONObject commandObj = JSON.parseObject(command);
        Integer mode = commandObj.getInteger("mode");

        String deviceMsgType = "command";
        JSONObject fakeCommand = new JSONObject();
        fakeCommand.put("deviceNo", device.getDeviceNo());
        fakeCommand.put("deviceType", device.getDeviceType());
        fakeCommand.put("commandType", commandObj.getInteger("mode"));
        fakeCommand.put("commandBody", command);
        if (mode == 1) {
            //取放货
            fakeCommandMap.put(String.valueOf(SlaveType.Lift) + device.getDeviceNo(), fakeCommand);
            response = genereateFakeCommandResponse();
        } else if (mode == 2) {
            //小车换层
            fakeCommandMap.put(String.valueOf(SlaveType.Lift) + device.getDeviceNo(), fakeCommand);
            response = genereateFakeCommandResponse();
        } else if (mode == 3) {
            //提升机移动
            fakeCommandMap.put(String.valueOf(SlaveType.Lift) + device.getDeviceNo(), fakeCommand);
            response = genereateFakeCommandResponse();
        } else if (mode == 9996) {
            //复位
            fakeCommandMap.put(String.valueOf(SlaveType.Lift) + device.getDeviceNo(), fakeCommand);
            response = genereateFakeCommandResponse();
        } else if (mode == 9997) {
            //切换入库模式
            fakeCommandMap.put(String.valueOf(SlaveType.Lift) + device.getDeviceNo(), fakeCommand);
            response = genereateFakeCommandResponse();
        } else if (mode == 9998) {
            //切换出库模式
            fakeCommandMap.put(String.valueOf(SlaveType.Lift) + device.getDeviceNo(), fakeCommand);
            response = genereateFakeCommandResponse();
        } else if (mode == 9999) {
            //读取状态
            response = genereateFakeStatusResponse(fakeStatus);
            deviceMsgType = "status";
        }

        fakeStatusMap.put(String.valueOf(SlaveType.Lift) + device.getDeviceNo(), fakeStatus);

        if (deviceMsgType.equals("command")) {
            log.info("收到Rcs Lift Command Data: {}", JSON.toJSONString(deviceCommandMsgModel));
        }
        DeviceMsgModel deviceMsgModel = new DeviceMsgModel();
        deviceMsgModel.setDeviceId(device.getDeviceNo());
        deviceMsgModel.setDeviceMsgType(deviceMsgType);
        deviceMsgModel.setDeviceMsg(response);
        deviceMsgModel.setDeviceOriginMsg(JSON.toJSONString(response));
        deviceMsgModel.setResultKey(deviceCommandMsgModel.getResultKey());
        deviceMsgUtils.sendDeviceMsg(SlaveType.Lift, device.getDeviceNo(), deviceMsgModel);
    }

    public HashMap<String, Object> genereateFakeStatusResponse(JSONObject fakeStatus) {
        JSONObject device = new JSONObject();
        HashMap<String, Object> resultData = new HashMap<>();
        resultData.put("result", "success");
        resultData.put("deviceStatus", device);


        device.put("model", fakeStatus.getInteger("model"));
        device.put("plcTaskNo", fakeStatus.getInteger("plcTaskNo"));
        device.put("protocolStatus", fakeStatus.getInteger("protocolStatus"));
        device.put("taskMode", fakeStatus.getInteger("taskMode"));
        device.put("pick", fakeStatus.getInteger("pick"));
        device.put("put", fakeStatus.getInteger("put"));
        device.put("iOMode", fakeStatus.getInteger("iOMode"));
        device.put("errorCode", fakeStatus.getInteger("errorCode"));
        device.put("hasTray", fakeStatus.getInteger("hasTray"));
        device.put("hasCar", fakeStatus.getInteger("hasCar"));
        device.put("lev", fakeStatus.getInteger("lev"));

        Object trayListObj = fakeStatus.get("trayList");
        List<Integer> trayList = new ArrayList<>();
        if (trayListObj != null) {
            trayList = JSON.parseArray(JSON.toJSONString(trayListObj), Integer.class);
        }

        Object carListObj = fakeStatus.get("carList");
        List<Integer> carList = new ArrayList<>();
        if (carListObj != null) {
            carList = JSON.parseArray(JSON.toJSONString(carListObj), Integer.class);
        }

        device.put("trayList", trayList);
        device.put("carList", carList);

        JSONObject extend = fakeStatus.getJSONObject("extend");
        device.put("frontOverrun", extend.getBoolean("frontOverrun"));
        device.put("backOverrun", extend.getInteger("backOverrun"));
        device.put("leftOverrun", extend.getInteger("leftOverrun"));
        device.put("rightOverrun", extend.getInteger("rightOverrun"));
        device.put("overHeight", extend.getInteger("overHeight"));
        device.put("overWeight", extend.getInteger("overWeight"));
        return resultData;
    }

    public HashMap<String, Object> genereateFakeCommandResponse() {
        HashMap<String, Object> resultData = new HashMap<>();
        resultData.put("result", "success");
        return resultData;
    }

    @Override
    public boolean connect() {
        return true;
    }

    @Override
    public void close() {

    }

    @Override
    public ConcurrentHashMap<String, Thread> getFakeThreadMap() {
        return this.fakeThreadMap;
    }

    @Override
    public ConcurrentHashMap<String, JSONObject> getFakeStatusMap() {
        return this.fakeStatusMap;
    }

    @Override
    public ConcurrentHashMap<String, JSONObject> getFakeCommandMap() {
        return this.fakeCommandMap;
    }

    @Override
    public boolean updateFakeStatus(UpdateFakeThreadStatusParam param) {
        String key = param.getDeviceType() + param.getDeviceNo();
        JSONObject result = fakeStatusMap.get(key);
        if (result == null) {
            return false;
        }

        JSONObject newData = JSON.parseObject(param.getData());
        this.fakeStatusMap.put(key, newData);
        return true;
    }
}

 src/main/java/com/zy/core/thread/fake/FakeZyForkLiftThread.java

@@ -155,7 +155,7 @@
                    Thread.sleep(5000);

                    fakeStatus.put("protocolStatus", 98);//等待确认
                    fakeStatus.put("lev", command.getInteger("put"));
                    fakeStatus.put("lev", commandBody.getInteger("put"));
                    fakeStatusMap.put(key, fakeStatus);
                } else if (commandType == 4) {
                    //小车换层

 src/main/java/com/zy/core/thread/impl/NyLiftThread.java

New file
@@ -0,0 +1,308 @@
package com.zy.core.thread.impl;

import HslCommunication.Core.Types.OperateResult;
import HslCommunication.Core.Types.OperateResultExOne;
import HslCommunication.Profinet.Siemens.SiemensPLCS;
import HslCommunication.Profinet.Siemens.SiemensS7Net;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.zy.common.SpringUtils;
import com.zy.common.utils.DateUtils;
import com.zy.common.utils.RedisUtil;
import com.zy.core.News;
import com.zy.core.cache.OutputQueue;
import com.zy.core.enums.RedisKeyType;
import com.zy.core.enums.SlaveType;
import com.zy.core.model.DeviceCommandMsgModel;
import com.zy.core.model.DeviceMsgModel;
import com.zy.core.properties.DeviceConfig;
import com.zy.core.thread.LiftThread;
import com.zy.core.utils.DeviceMsgUtils;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

@Slf4j
@SuppressWarnings("all")
public class NyLiftThread implements LiftThread {

    private DeviceConfig deviceConfig;
    private RedisUtil redisUtil;
    private SiemensS7Net siemensS7Net;
    private boolean connect = false;

    public NyLiftThread(DeviceConfig deviceConfig, RedisUtil redisUtil) {
        this.deviceConfig = deviceConfig;
        this.redisUtil = redisUtil;
    }

    @Override
    public boolean connect() {
        if (deviceConfig.getFake()) {
            this.connect = true;
            OutputQueue.LIFT.offer(MessageFormat.format( "【{0}】提升机连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), deviceConfig.getDeviceNo(), deviceConfig.getIp(), deviceConfig.getPort(), 0, 0));
            News.info("【{}】提升机连接成功 ===>> [id:{}] [ip:{}] [port:{}]", DateUtils.convert(new Date()), deviceConfig.getDeviceNo(), deviceConfig.getIp(), deviceConfig.getPort());
            return true;
        }

        boolean result = false;
        siemensS7Net = new SiemensS7Net(SiemensPLCS.S1200, deviceConfig.getIp());
        siemensS7Net.setRack(Integer.valueOf(0).byteValue());
        siemensS7Net.setSlot(Integer.valueOf(0).byteValue());
        OperateResult connect = siemensS7Net.ConnectServer();
        if(connect.IsSuccess){
            result = true;
            OutputQueue.LIFT.offer(MessageFormat.format( "【{0}】提升机连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}] [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), deviceConfig.getDeviceNo(), deviceConfig.getIp(), deviceConfig.getPort(), 0, 0));
            News.info("【{}】提升机连接成功 ===>> [id:{}] [ip:{}] [port:{}]", DateUtils.convert(new Date()), deviceConfig.getDeviceNo(), deviceConfig.getIp(), deviceConfig.getPort());
        } else {
            OutputQueue.LIFT.offer(MessageFormat.format( "【{0}】提升机连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}]  [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), deviceConfig.getDeviceNo(), deviceConfig.getIp(), deviceConfig.getPort(), 0, 0));
            News.error("【{}】提升机连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}]", DateUtils.convert(new Date()), deviceConfig.getDeviceNo(), deviceConfig.getIp(), deviceConfig.getPort());
        }
        // siemensS7Net.ConnectClose();
        this.connect = result;
        return result;
    }

    @Override
    public void close() {

    }

    @Override
    public void run() {
        News.info("{}号提升机线程启动", deviceConfig.getDeviceNo());
        this.connect();
        while (true) {
            try {
                DeviceMsgUtils deviceMsgUtils = null;
                try {
                    deviceMsgUtils = SpringUtils.getBean(DeviceMsgUtils.class);
                }catch (Exception e){}
                if (deviceMsgUtils == null) {
                    continue;
                }
                DeviceCommandMsgModel deviceCommandMsg = deviceMsgUtils.getDeviceCommandMsg(SlaveType.Lift, deviceConfig.getDeviceNo());
                if (deviceCommandMsg == null) {
                    continue;
                }
                executeCommand(deviceCommandMsg, deviceMsgUtils);

                Thread.sleep(200);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void executeCommand(DeviceCommandMsgModel deviceCommandMsg, DeviceMsgUtils deviceMsgUtils) {
        if (deviceConfig.getFake()) {
            redisUtil.set(RedisKeyType.FAKE_DEVICE_LIFT_COMMAND_MSG_KEY.key + deviceConfig.getDeviceNo(), deviceCommandMsg, 60 * 60);
            return;
        }

        String command = JSON.toJSONString(deviceCommandMsg.getCommand());
        JSONObject commandObj = JSON.parseObject(command);

        HashMap<String, Object> resultData = new HashMap<>();
        resultData.put("result", "false");

        String deviceMsgType = "command";
        OperateResult result = null;
        OperateResult result2 = null;
        if (commandObj.getInteger("mode") == 3) {
            //取放货
            short[] array = new short[4];
            array[0] = commandObj.getShort("taskNO");//任务号
            array[1] = commandObj.getShort("mode");//任务模式
            array[2] = commandObj.getShort("pick");//取货数据
            array[3] = commandObj.getShort("put");//放货数据
            resultData.put("commandData", array);

            result = siemensS7Net.Write("DB103.0", array);
            if (result.IsSuccess) {
                result2 = siemensS7Net.Write("DB103.8", (short) 1);
                if (result2.IsSuccess) {
                    resultData.put("result", "success");
                }
            }
        } else if (commandObj.getInteger("mode") == 4) {
            //小车换层
            short[] array = new short[4];
            array[0] = commandObj.getShort("taskNO");//任务号
            array[1] = commandObj.getShort("mode");//任务模式
            array[2] = commandObj.getShort("pick");//取货数据
            array[3] = commandObj.getShort("put");//放货数据
            resultData.put("commandData", array);

            result = siemensS7Net.Write("DB103.0", array);
            if (result.IsSuccess) {
                result2 = siemensS7Net.Write("DB103.8", (short) 1);
                if (result2.IsSuccess) {
                    resultData.put("result", "success");
                }
            }
        } else if (commandObj.getInteger("mode") == 5) {
            //提升机移动
            short[] array = new short[4];
            array[0] = commandObj.getShort("taskNO");//任务号
            array[1] = commandObj.getShort("mode");//任务模式
            array[2] = commandObj.getShort("pick");//取货数据
            array[3] = commandObj.getShort("put");//放货数据
            resultData.put("commandData", array);

            result = siemensS7Net.Write("DB103.0", array);
            if (result.IsSuccess) {
                result2 = siemensS7Net.Write("DB103.8", (short) 1);
                if (result2.IsSuccess) {
                    resultData.put("result", "success");
                }
            }
        } else if (commandObj.getInteger("mode") == 9996) {
            //复位
            short[] array = new short[1];
            array[0] = 1;
            resultData.put("commandData", array);

            result = siemensS7Net.Write("DB103.10", array);
            if (result.IsSuccess) {
                resultData.put("result", "success");
            }
        } else if (commandObj.getInteger("mode") == 9997) {
            //切换入库模式
            short[] array = new short[1];
            array[0] = 1;
            resultData.put("commandData", array);

            result = siemensS7Net.Write("DB103.12", array);
            if (result.IsSuccess) {
                resultData.put("result", "success");
            }
        } else if (commandObj.getInteger("mode") == 9998) {
            //切换出库模式
            short[] array = new short[1];
            array[0] = 2;
            resultData.put("commandData", array);

            result = siemensS7Net.Write("DB103.12", array);
            if (result.IsSuccess) {
                resultData.put("result", "success");
            }
        } else if (commandObj.getInteger("mode") == 9999) {
            //读取状态
            JSONObject device = new JSONObject();

            OperateResultExOne<byte[]> readResult1 = siemensS7Net.Read("DB101.0", (short) 18);
            if (readResult1.IsSuccess) {
                //模式
                device.put("model", (int) siemensS7Net.getByteTransform().TransInt16(readResult1.Content, 0));
                //PLC任务号
                device.put("wrkNo", (int) siemensS7Net.getByteTransform().TransInt16(readResult1.Content, 2));
                //任务状态
                device.put("protocolStatus", (int) siemensS7Net.getByteTransform().TransInt16(readResult1.Content, 4));
                //任务模式
                device.put("taskMode", (int) siemensS7Net.getByteTransform().TransInt16(readResult1.Content, 6));
                //取货数据
                device.put("pick", (int) siemensS7Net.getByteTransform().TransInt16(readResult1.Content, 8));
                //放货数据
                device.put("put", (int) siemensS7Net.getByteTransform().TransInt16(readResult1.Content, 10));
                //出入库模式
                device.put("iOMode", (int) siemensS7Net.getByteTransform().TransInt16(readResult1.Content, 12));
                //故障码
                device.put("errorCode", (int) siemensS7Net.getByteTransform().TransInt16(readResult1.Content, 14));
                //层
                device.put("lev", (int) siemensS7Net.getByteTransform().TransInt16(readResult1.Content, 16));

                resultData.put("deviceStatus", device);
            }

            //站点个数
            int staCount = 4;
            //读取托盘数据
            List<Integer> trayList = new ArrayList<>();
            OperateResultExOne<byte[]> readResult2 = siemensS7Net.Read("DB102.0", (short) (staCount * 2));
            if(readResult2.IsSuccess) {
                for (int i = 0; i < staCount; i++) {
                    short val = siemensS7Net.getByteTransform().TransInt16(readResult2.Content, i * 2);
                    trayList.add((int) val);
                }
            }

            //读取小车数据
            OperateResultExOne<byte[]> readResult3 = siemensS7Net.Read("DB102.50", (short) (staCount * 2));
            List<Integer> carList = new ArrayList<>();
            if(readResult3.IsSuccess) {
                for (int i = 0; i < staCount; i++) {
                    short val = siemensS7Net.getByteTransform().TransInt16(readResult3.Content, i * 2);
                    carList.add((int) val);
                }
            }

            device.put("trayList", trayList);
            device.put("carList", carList);

            deviceMsgType = "status";
        }

        resultData.put("commandResult1", JSON.toJSONString(result));
        resultData.put("commandResult2", JSON.toJSONString(result2));

        if (deviceMsgType.equals("command")) {
            log.info("收到Rcs Lift Command Data: {}", JSON.toJSONString(deviceCommandMsg));
        }
        DeviceMsgModel deviceMsgModel = new DeviceMsgModel();
        deviceMsgModel.setDeviceId(deviceConfig.getDeviceNo());
        deviceMsgModel.setDeviceMsgType(deviceMsgType);
        deviceMsgModel.setDeviceMsg(JSON.toJSONString(resultData));
        deviceMsgModel.setDeviceOriginMsg(JSON.toJSONString(resultData));
        deviceMsgModel.setResultKey(deviceCommandMsg.getResultKey());
        deviceMsgUtils.sendDeviceMsg(SlaveType.Lift, deviceConfig.getDeviceNo(), deviceMsgModel);
    }

    @Override
    public DeviceConfig getDeviceConfig() {
        return this.deviceConfig;
    }

    /**
     * 扩展字段
     */
    @Data
    private class InnerLiftExtend {

        /**
         * 前超限
         */
        private Boolean frontOverrun;

        /**
         * 后超限
         */
        private Boolean backOverrun;

        /**
         * 左超限
         */
        private Boolean leftOverrun;

        /**
         * 右超限
         */
        private Boolean rightOverrun;

        /**
         * 超高
         */
        private Boolean overHeight;

        /**
         * 超重
         */
        private Boolean overWeight;

    }
}

 src/main/java/com/zy/core/utils/DeviceMsgUtils.java

@@ -137,6 +137,8 @@
            return RedisKeyType.DEVICE_SHUTTLE_MSG_KEY_.key + deviceId + "_";
        } else if (deviceType.equals(SlaveType.ForkLift)) {
            return RedisKeyType.DEVICE_FORK_LIFT_MSG_KEY_.key + deviceId + "_";
        } else if (deviceType.equals(SlaveType.Lift)) {
            return RedisKeyType.DEVICE_LIFT_MSG_KEY_.key + deviceId + "_";
        }else {
            throw new CoolException("设备类型未定义");
        }
@@ -151,6 +153,8 @@
            return RedisKeyType.DEVICE_SHUTTLE_COMMAND_MSG_KEY.key + deviceId + "_";
        } else if (deviceType.equals(SlaveType.ForkLift)) {
            return RedisKeyType.DEVICE_FORK_LIFT_COMMAND_MSG_KEY.key + deviceId + "_";
        } else if (deviceType.equals(SlaveType.Lift)) {
            return RedisKeyType.DEVICE_LIFT_COMMAND_MSG_KEY.key + deviceId + "_";
        }else {
            throw new CoolException("设备类型未定义");
        }