#

zjj

2025-07-02 d3f3d4b309cfb285fcbbc48b91c4046111c7e9cd

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

@@ -9,7 +9,6 @@
import com.core.common.DateUtils;
import com.core.common.SpringUtils;
import com.core.exception.CoolException;
import com.zy.asrs.domain.enums.TaskStatusType;
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.entity.CommandInfo;
import com.zy.asrs.entity.CommandInfoLog;
@@ -29,10 +28,7 @@
import lombok.extern.slf4j.Slf4j;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
@@ -71,6 +67,12 @@
        add(400);add(401);add(402);add(403);
        add(404);add(405);add(406);add(407);
    }};
    public static final ArrayList<Integer> hoist1 = new ArrayList<Integer>() {{
        add(302);add(303);
    }};
    public static final ArrayList<Integer> hoist2 = new ArrayList<Integer>() {{
        add(402);add(403);
    }};

    /**
     * 条码数量
@@ -97,6 +99,17 @@
                return staNos3;
            case 4:
                return staNos4;
            default:
                throw new CoolException("服务器异常");
        }
    }

    private ArrayList<Integer> getHoist() {
        switch (slave.getId()) {
            case 3:
                return hoist1;
            case 4:
                return hoist2;
            default:
                throw new CoolException("服务器异常");
        }
@@ -131,6 +144,9 @@
                        write2((StaProtocol)task.getData());
                        read();
                        break;
                    case 4:
                        write3((StaProtocol)task.getData());
                        break;
                    default:
                        break;
                }
@@ -141,6 +157,38 @@
                e.printStackTrace();
            }

        }
    }

    // 写组拓信号(没有查询到该托盘码任务)
    private void write3(StaProtocol staProtocol) {
        // 一个short=两个字节=2*byte 1byte = 8位
        // 先读一次
        OperateResultExOne<byte[]> read = siemensS7Net.Read("DB100.200", (short) 1);
        if(read.IsSuccess){
            byte[] content = read.Content;
            boolean[] array = siemensS7Net.getByteTransform().TransBool(content, 0,1);
            // 如果已经为true，则不重复写
            boolean flag = false;
            switch (staProtocol.getSiteId()) {
                case 103: if(array[0]) {
                } else array[0] = true; flag = true; break;
                case 107: if(array[1]) {
                } else array[1] = true; flag = true; break;
                case 111: if(array[2]) {
                } else array[2] = true; flag = true; break;
                case 115: if(array[3]) {
                } else array[3] = true; flag = true; break;
                case 119: if(array[4]) {
                } else array[4] = true; flag = true; break;
                case 123: if(array[5]) {
                } else array[5] = true; flag = true; break;
                default:
            }
            if (flag) {
                siemensS7Net.Write("DB100.200", array);
                log.info("写入组托信号：{}", Arrays.toString(array));
            }
        }
    }

@@ -180,6 +228,7 @@
                staProtocol.setWorkNo((short) 0);
                staProtocol.setNearbySta((short) 1);
                staProtocol.setLoading(false);
                staProtocol.setAutoing(false);
            }
        }
    }
@@ -269,9 +318,39 @@
                        station.put((i+1), staProtocol);
                    }
                    staProtocol.setWorkNo(wrkNo);
                    staProtocol.setAutoing(true);
                    staProtocol.setNearbySta(location);
                    staProtocol.setLoading(status[0]);
                }
            }
        }
        if (slave.getId() == 3 || slave.getId() == 4){
            ArrayList<Integer> hoist = getHoist();
            int hoistSize = hoist.size();
            OperateResultExOne<byte[]> resultHoist = siemensS7Net.Read("DB15.0", (short) 33);
            if (resultHoist.IsSuccess) {
                    Integer siteId = hoist.get(0); // 站点编号
                    StaProtocol staProtocol = station.get(siteId);
                    if (null == staProtocol) {
                        staProtocol = new StaProtocol();
                        staProtocol.setSiteId(siteId);
                        station.put(siteId, staProtocol);
                    }
                    boolean[] status = siemensS7Net.getByteTransform().TransBool(resultHoist.Content, 32, 1);
                    staProtocol.setPlace1(status[0]);
                    staProtocol.setPlace2(status[1]);

                Integer siteId2 = hoist.get(1); // 站点编号
                staProtocol = station.get(siteId2);
                if (null == staProtocol) {
                    staProtocol = new StaProtocol();
                    staProtocol.setSiteId(siteId);
                    station.put(siteId, staProtocol);
                }
                boolean[] status2 = siemensS7Net.getByteTransform().TransBool(resultHoist.Content, 32, 1);
                staProtocol.setPlace1(status2[2]);
                staProtocol.setPlace2(status2[3]);

            }
        }

@@ -432,14 +511,14 @@
                    Integer siteId = staNos.get(i); // 站点编号
                    boolean[] status = siemensS7Net.getByteTransform().TransBool(resultErr.Content, i*4, 1);
                    StaProtocol staProtocol = station.get(siteId);
                    staProtocol.setBreakerErr(status[0]);
                    staProtocol.setInfraredErr(status[1]);
                    staProtocol.setBreakerErr(status[0]); //提升机 上升极限
                    staProtocol.setInfraredErr(status[1]); //提升机 下降极限
                    staProtocol.setOutTimeErr(status[2]);
                    staProtocol.setSeizeSeatErr(status[3]);
                    staProtocol.setWrkYgoodsN(status[4]);
                    staProtocol.setInverterErr(status[5]);
                    staProtocol.setContactErr(status[6]);
                    staProtocol.setUpcontactErr(status[7]);
                    staProtocol.setContactErr(status[6]); //提升机 左超限
                    staProtocol.setUpcontactErr(status[7]); //提升机 右超限

                }
            }
@@ -578,7 +657,7 @@
                    if(staProtocol.getWorkNo().equals(workNo) && staProtocol.getStaNo().equals(staNo)){
                        //任务命令写入成功
                        writeFlag = true;
                        log.info("写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                        log.info("222写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);

                        Date now = new Date();

@@ -608,7 +687,7 @@
                        writeCount++;
                        OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线命令后返回成功，但是读取任务值不一致。输送线plc编号={1}，站点数据={2},写入次数={3}",
                                slave.getId(), JSON.toJSON(staProtocol),writeCount));
                        log.error("写入输送线命令后返回成功，但是读取任务值不一致。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                        log.error("222写入输送线命令后返回成功，但是读取任务值不一致。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                        //更新指令日志
                        commandInfoLog.setDeviceLog("指令下发失败");
                        commandInfoLogService.insert(commandInfoLog);
@@ -617,7 +696,7 @@
                    writeCount++;
                    OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线命令后读取失败。输送线plc编号={1}，站点数据={2},写入次数={3}",
                            slave.getId(), JSON.toJSON(staProtocol), writeCount));
                    log.error("写入输送线命令后读取失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                    log.error("222写入输送线命令后读取失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);

                    //更新指令日志
                    commandInfoLog.setDeviceLog("指令下发失败");
@@ -627,7 +706,7 @@
                writeCount++;
                OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线命令失败。输送线plc编号={1}，站点数据={2},写入次数={3}",
                        slave.getId(), JSON.toJSON(staProtocol),writeCount));
                log.error("写入输送线命令失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                log.error("222写入输送线命令失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);

                //更新指令日志
                commandInfoLog.setDeviceLog("指令下发失败");
@@ -643,10 +722,9 @@
                staProtocol.setPakMk(true);
            }
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线命令尝试5次失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(staProtocol)));
            log.error("写入输送线命令尝试5次失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));
            log.error("222写入输送线命令尝试5次失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));

            //重新添加数据到任务队列
            boolean result = MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(2, staProtocol));

            read();//读取1次设备状态
            return;
        } else {
@@ -689,29 +767,28 @@
                    if(staProtocol.getWorkNo().equals(workNo) && staProtocol.getStaNo().equals(staNo)){
                        //任务命令写入成功
                        writeFlag = true;
                        log.info("写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                        log.info("3333写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);

                        Date now = new Date();
                        break;
                    } else {//返回结果是成功了，但是真实值不相同
                        writeCount++;
                        OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线命令后返回成功，但是读取任务值不一致。输送线plc编号={1}，站点数据={2},写入次数={3}",
                                slave.getId(), JSON.toJSON(staProtocol),writeCount));
                        log.error("写入输送线命令后返回成功，但是读取任务值不一致。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                        log.error("333写入输送线命令后返回成功，但是读取任务值不一致。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);

                    }
                } else {
                    writeCount++;
                    OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线命令后读取失败。输送线plc编号={1}，站点数据={2},写入次数={3}",
                            slave.getId(), JSON.toJSON(staProtocol), writeCount));
                    log.error("写入输送线命令后读取失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                    log.error("333写入输送线命令后读取失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);

                }
            } else {
                writeCount++;
                OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线命令失败。输送线plc编号={1}，站点数据={2},写入次数={3}",
                        slave.getId(), JSON.toJSON(staProtocol),writeCount));
                log.error("写入输送线命令失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
                log.error("333写入输送线命令失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);

            }
            Thread.sleep(200);
@@ -727,7 +804,7 @@
            log.error("写入输送线命令尝试5次失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));

            //重新添加数据到任务队列
            boolean result = MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(3, staProtocol));

            read();//读取1次设备状态
            return;
        } else {