#

lsh

2024-05-16 8353d857cae5c623e29406dcbe8c9a870d527b6e

#

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

@@ -62,10 +62,10 @@
            MessageQueue.init(SlaveType.Rgv, rgv);
        }

        // 初始化机械臂mq
        for (Slave ext : slaveProperties.getExt()) {
            MessageQueue.init(SlaveType.Ext, ext);
        }
//        // 初始化机械臂mq
//        for (Slave ext : slaveProperties.getExt()) {
//            MessageQueue.init(SlaveType.Ext, ext);
//        }
//        // 初始化Led灯mq
//        for (Slave led : slaveProperties.getLed()) {
//            MessageQueue.init(SlaveType.Led, led);
@@ -88,13 +88,13 @@
//            new Thread((Runnable) crnThread).start();
//            SlaveConnection.put(SlaveType.Crn, crn.getId(), crnThread);
//        }
//        // 初始化输送线线程
//        log.info("初始化输送线线程...................................................");
//        for (DevpSlave devp : slaveProperties.getDevp()) {
//            DevpThread devpThread = new SiemensDevpThread(devp);
//            new Thread((Runnable) devpThread).start();
//            SlaveConnection.put(SlaveType.Devp, devp.getId(), devpThread);
//        }
        // 初始化输送线线程
        log.info("初始化输送线线程...................................................");
        for (DevpSlave devp : slaveProperties.getDevp()) {
            DevpThread devpThread = new SiemensDevpThread(devp);
            new Thread((Runnable) devpThread).start();
            SlaveConnection.put(SlaveType.Devp, devp.getId(), devpThread);
        }
//        // 初始化条码扫描仪线程
//        log.info("初始化条码扫描仪线程...................................................");
//        for (Slave barcode : slaveProperties.getBarcode()) {
@@ -109,13 +109,13 @@
            new Thread((Runnable) rgvThread).start();
            SlaveConnection.put(SlaveType.Rgv, rgv.getId(), rgvThread);
        }
        // 初始化机械臂线程
        log.info("初始化Ext线程...................................................");
        for (ExtSlave ext : slaveProperties.getExt()) {
            MelsecExtThread extThread = new MelsecExtThread(ext);
            new Thread(extThread).start();
            SlaveConnection.put(SlaveType.Ext, ext.getId(), extThread);
        }
//        // 初始化机械臂线程
//        log.info("初始化Ext线程...................................................");
//        for (ExtSlave ext : slaveProperties.getExt()) {
//            MelsecExtThread extThread = new MelsecExtThread(ext);
//            new Thread(extThread).start();
//            SlaveConnection.put(SlaveType.Ext, ext.getId(), extThread);
//        }
//        // 初始化LED线程
//        log.info("初始化LED线程...................................................");
//        for (LedSlave led : slaveProperties.getLed()) {

 src/main/java/com/zy/core/model/protocol/StaProtocol.java

@@ -26,31 +26,31 @@
    private Short staNo;

    // ----------------------------------------------------------------
    // 自动
    // 输送线 ==》 氮气1
    private boolean autoing;

    // 有物
    // 输送线 ==》 氮气2
    private boolean loading;

    // 可入
    // 输送线 ==》 氮气3
    private boolean inEnable;

    // 可出
    // 输送线 ==》 氮气4
    private boolean outEnable;

    // 空板信号
    // 氮气1 ==》 下料位
    private boolean emptyMk;

    // 满托盘
    // 氮气2 ==》 下料位
    private boolean fullPlt;

    // 高
    private boolean high = false;

    // 低
    // 氮气4 ==》 下料位
    private boolean low;

    //agv
    //氮气3 ==》 下料位
    private boolean car;

    // 锁定标记

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

@@ -48,33 +48,35 @@
    private Map<Integer, StaProtocol> station = new ConcurrentHashMap<>();
    private short heartBeatVal = 1;
    public static final ArrayList<Integer> staNos1 = new ArrayList<Integer>() {{
        add(100);add(101);add(102);add(103);add(104);add(105);add(106);add(107);add(108);add(109);add(110);add(111);
        add(112);add(113);add(114);add(115);add(116);add(117);add(118);add(119);add(120);add(121);add(122);add(123);
        add(100);
//        add(101);add(102);add(103);add(104);add(105);add(106);add(107);
//        add(108);add(109);add(110);add(111);
//        add(112);add(113);add(114);add(115);add(116);add(117);add(118);add(119);add(120);add(121);add(122);add(123);
    }};
    public static final ArrayList<Integer> staNos2 = new ArrayList<Integer>() {{
        add(200);add(201);add(202);add(203);
        add(204);add(205);add(206);add(207);
        add(208);add(209);add(210);add(211);
        add(212);add(213);add(214);add(215);
        add(216);add(217);add(218);add(219);
        add(220);add(221);add(222);add(223);
        add(224);add(225);add(226);add(227);
        add(228);add(229);add(230);add(231);
        add(232);add(233);add(234);add(235);
    }};
    public static final ArrayList<Integer> staNos3 = new ArrayList<Integer>() {{
        add(300);add(301);add(302);add(303);
        add(304);add(305);add(306);add(307);
    }};
    public static final ArrayList<Integer> staNos4 = new ArrayList<Integer>() {{
        add(400);add(401);add(402);add(403);
        add(404);add(405);add(406);add(407);
    }};
//    public static final ArrayList<Integer> staNos2 = new ArrayList<Integer>() {{
//        add(200);add(201);add(202);add(203);
//        add(204);add(205);add(206);add(207);
//        add(208);add(209);add(210);add(211);
//        add(212);add(213);add(214);add(215);
//        add(216);add(217);add(218);add(219);
//        add(220);add(221);add(222);add(223);
//        add(224);add(225);add(226);add(227);
//        add(228);add(229);add(230);add(231);
//        add(232);add(233);add(234);add(235);
//    }};
//    public static final ArrayList<Integer> staNos3 = new ArrayList<Integer>() {{
//        add(300);add(301);add(302);add(303);
//        add(304);add(305);add(306);add(307);
//    }};
//    public static final ArrayList<Integer> staNos4 = new ArrayList<Integer>() {{
//        add(400);add(401);add(402);add(403);
//        add(404);add(405);add(406);add(407);
//    }};

    /**
     * 条码数量
     */
    private int barcodeSize = 7;
    private int barcodeSize = 1;

    /**
     * 入出库模式
@@ -90,12 +92,12 @@
        switch (slave.getId()) {
            case 1:
                return staNos1;
            case 2:
                return staNos2;
            case 3:
                return staNos3;
            case 4:
                return staNos4;
//            case 2:
//                return staNos2;
//            case 3:
//                return staNos3;
//            case 4:
//                return staNos4;
            default:
                throw new CoolException("服务器异常");
        }
@@ -200,7 +202,7 @@
//        updateIoMode();
        ArrayList<Integer> staNos = getStaNo();
        int staNoSize = staNos.size();
        OperateResultExOne<byte[]> result = siemensS7Net.Read("DB100.0", (short) (staNoSize*4));
        OperateResultExOne<byte[]> result = siemensS7Net.Read("DB58.0", (short) (1));
        if (result.IsSuccess) {
            for (int i = 0; i < staNoSize; i++) {
                Integer siteId = staNos.get(i); // 站点编号
@@ -210,202 +212,196 @@
                    staProtocol.setSiteId(siteId);
                    station.put(siteId, staProtocol);
                }
                staProtocol.setWorkNo(siemensS7Net.getByteTransform().TransInt16(result.Content, i*4));     // 工作号
                staProtocol.setWorkNo((short)0);     // 工作号

                staProtocol.setStaNo(siemensS7Net.getByteTransform().TransInt16(result.Content, i*4 + 2));   // 目标站
            }
        }

        //Thread.sleep(200);
        OperateResultExOne<byte[]> result1 = siemensS7Net.Read("DB101.0", (short) (staNoSize*2));
        if (result1.IsSuccess) {
            for (int i = 0; i < staNoSize; i++) {
                Integer siteId = staNos.get(i); // 站点编号
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result1.Content, i*2, 1);
                StaProtocol staProtocol = station.get(siteId);
                staProtocol.setAutoing(status[0]);  // 自动
                staProtocol.setLoading(status[1]);  // 有物
                staProtocol.setInEnable(status[2]); // 可入
                staProtocol.setOutEnable(status[3]);// 可出
                staProtocol.setEmptyMk(status[4]);  // 空板信号
                staProtocol.setFullPlt(status[5]);  // 满托盘
                staProtocol.setCar(status[6]);     // 是否有车
                staProtocol.setLow(status[7]);      // 低库位

                if (!staProtocol.isPakMk() && !staProtocol.isLoading()) {
                    staProtocol.setPakMk(true);
                }
            }
        }


        if (slave.getId() == 1){
            //条码
            //Thread.sleep(200);
            OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB101.102",(short)60);
            if (result2.IsSuccess) {
                for (int i = 0; i < 6; i++) {
                    String barcode = siemensS7Net.getByteTransform().TransString(result2.Content,i*10,8, "UTF-8");
                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, i + 1);
                    if(!Cools.isEmpty(barcodeThread) && !barcodeThread.getBarcode().equals(barcode)) {
                        barcodeThread.setBarcode(barcode);
                    }
                }
            }

            // 外形检测 - 102
            //Thread.sleep(100);
            OperateResultExOne<byte[]> result4 = siemensS7Net.Read("DB101.160", (short)1);
            if (result4.IsSuccess) {
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result4.Content, 0, 1);
                StaProtocol staProtocol = station.get(103);
                staProtocol.setFrontErr(status[0]);
                staProtocol.setBackErr(status[1]);
                staProtocol.setHighErr(status[2]);
                staProtocol.setLeftErr(status[3]);
                staProtocol.setRightErr(status[4]);
                staProtocol.setWeightErr(status[5]);
                staProtocol.setBarcodeErr(status[6]);
            }
            // 外形检测 - 107
            //Thread.sleep(50);
            OperateResultExOne<byte[]> result5 = siemensS7Net.Read("DB101.164", (short)1);
            if (result5.IsSuccess) {
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result5.Content, 0, 1);
                StaProtocol staProtocol = station.get(107);
                staProtocol.setFrontErr(status[0]);
                staProtocol.setBackErr(status[1]);
                staProtocol.setHighErr(status[2]);
                staProtocol.setLeftErr(status[3]);
                staProtocol.setRightErr(status[4]);
                staProtocol.setWeightErr(status[5]);
                staProtocol.setBarcodeErr(status[6]);
            }
            // 外形检测 - 111
            //Thread.sleep(50);
            OperateResultExOne<byte[]> result6 = siemensS7Net.Read("DB101.168", (short)1);
            if (result6.IsSuccess) {
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result6.Content, 0, 1);
                StaProtocol staProtocol = station.get(111);
                staProtocol.setFrontErr(status[0]);
                staProtocol.setBackErr(status[1]);
                staProtocol.setHighErr(status[2]);
                staProtocol.setLeftErr(status[3]);
                staProtocol.setRightErr(status[4]);
                staProtocol.setWeightErr(status[5]);
                staProtocol.setBarcodeErr(status[6]);
            }
            // 外形检测 - 115
            //Thread.sleep(50);
            OperateResultExOne<byte[]> result7 = siemensS7Net.Read("DB101.172", (short)1);
            if (result7.IsSuccess) {
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result7.Content, 0, 1);
                StaProtocol staProtocol = station.get(115);
                staProtocol.setFrontErr(status[0]);
                staProtocol.setBackErr(status[1]);
                staProtocol.setHighErr(status[2]);
                staProtocol.setLeftErr(status[3]);
                staProtocol.setRightErr(status[4]);
                staProtocol.setWeightErr(status[5]);
                staProtocol.setBarcodeErr(status[6]);
            }
            // 外形检测 - 119
            //Thread.sleep(50);
            OperateResultExOne<byte[]> result8 = siemensS7Net.Read("DB101.176", (short)1);
            if (result8.IsSuccess) {
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result8.Content, 0, 1);
                StaProtocol staProtocol = station.get(119);
                staProtocol.setFrontErr(status[0]);
                staProtocol.setBackErr(status[1]);
                staProtocol.setHighErr(status[2]);
                staProtocol.setLeftErr(status[3]);
                staProtocol.setRightErr(status[4]);
                staProtocol.setWeightErr(status[5]);
                staProtocol.setBarcodeErr(status[6]);
            }
            // 外形检测 - 123
            //Thread.sleep(50);
            OperateResultExOne<byte[]> result9 = siemensS7Net.Read("DB101.180", (short)1);
            if (result9.IsSuccess) {
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result9.Content, 0, 1);
                StaProtocol staProtocol = station.get(123);
                staProtocol.setFrontErr(status[0]);
                staProtocol.setBackErr(status[1]);
                staProtocol.setHighErr(status[2]);
                staProtocol.setLeftErr(status[3]);
                staProtocol.setRightErr(status[4]);
                staProtocol.setWeightErr(status[5]);
                staProtocol.setBarcodeErr(status[6]);
            }
        } else if (slave.getId() == 3) {
            //条码
            //Thread.sleep(200);
            OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB101.18",(short)10);
            if (result2.IsSuccess) {
                    String barcode = siemensS7Net.getByteTransform().TransString(result2.Content,0,8, "UTF-8");
                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, 7);
                    if(!Cools.isEmpty(barcodeThread) && !barcodeThread.getBarcode().equals(barcode)) {
                        barcodeThread.setBarcode(barcode);
                    }
            }
            OperateResultExOne<byte[]> result10 = siemensS7Net.Read("DB101.26", (short)1);
            if (result10.IsSuccess) {
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result10.Content, 0, 1);
                StaProtocol staProtocol = station.get(301);
                staProtocol.setFrontErr(status[0]);
                staProtocol.setBackErr(status[1]);
                staProtocol.setHighErr(status[2]);
                staProtocol.setLeftErr(status[3]);
                staProtocol.setRightErr(status[4]);
                staProtocol.setWeightErr(status[5]);
                staProtocol.setBarcodeErr(status[6]);
            }
        } else if (slave.getId() == 4) {
            //条码
            OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB101.18",(short)10);
            if (result2.IsSuccess) {

                String barcode = siemensS7Net.getByteTransform().TransString(result2.Content,0,8, "UTF-8");
                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, 8);
                if(!Cools.isEmpty(barcodeThread) && !barcodeThread.getBarcode().equals(barcode)) {
                    barcodeThread.setBarcode(barcode);
                }
            }
            // 外形检测 - 111
            //Thread.sleep(50);
            OperateResultExOne<byte[]> result10 = siemensS7Net.Read("DB101.26", (short)1);
            if (result10.IsSuccess) {
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result10.Content, 0, 1);
                StaProtocol staProtocol = station.get(401);
                staProtocol.setFrontErr(status[0]);
                staProtocol.setBackErr(status[1]);
                staProtocol.setHighErr(status[2]);
                staProtocol.setLeftErr(status[3]);
                staProtocol.setRightErr(status[4]);
                staProtocol.setWeightErr(status[5]);
                staProtocol.setBarcodeErr(status[6]);
                staProtocol.setStaNo((short)0);   // 目标站
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result.Content, 0, 1);
                staProtocol.setAutoing(status[0]);  // 输送线 ==》 氮气1
                staProtocol.setLoading(status[1]);  // 输送线 ==》 氮气2
                staProtocol.setInEnable(status[2]); // 输送线 ==》 氮气3
                staProtocol.setOutEnable(status[3]);// 输送线 ==》 氮气4
                staProtocol.setEmptyMk(status[4]);  // 氮气1 ==》 下料位
                staProtocol.setFullPlt(status[5]);  // 氮气2 ==》 下料位
                staProtocol.setCar(status[6]);     // 氮气3 ==》 下料位
                staProtocol.setLow(status[7]);      // 氮气4 ==》 下料位

            }
        }


        OperateResultExOne<byte[]> resultErr = siemensS7Net.Read("DB13.2", (short) (staNoSize*4));
        if (resultErr.IsSuccess) {
            for (int i = 0; i < staNoSize; i++) {
                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.setOutTimeErr(status[2]);
                staProtocol.setSeizeSeatErr(status[3]);
                staProtocol.setWrkYgoodsN(status[4]);
                staProtocol.setInverterErr(status[5]);
                staProtocol.setContactErr(status[6]);
                staProtocol.setUpcontactErr(status[7]);

            }
        }
//        //Thread.sleep(200);
//        OperateResultExOne<byte[]> result1 = siemensS7Net.Read("DB101.0", (short) (staNoSize*2));
//        if (result1.IsSuccess) {
//
//        }
//
//
//        if (slave.getId() == 1){
//            //条码
//            //Thread.sleep(200);
//            OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB101.102",(short)60);
//            if (result2.IsSuccess) {
//                for (int i = 0; i < 6; i++) {
//                    String barcode = siemensS7Net.getByteTransform().TransString(result2.Content,i*10,8, "UTF-8");
//                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, i + 1);
//                    if(!Cools.isEmpty(barcodeThread) && !barcodeThread.getBarcode().equals(barcode)) {
//                        barcodeThread.setBarcode(barcode);
//                    }
//                }
//            }
//
//            // 外形检测 - 102
//            //Thread.sleep(100);
//            OperateResultExOne<byte[]> result4 = siemensS7Net.Read("DB101.160", (short)1);
//            if (result4.IsSuccess) {
//                boolean[] status = siemensS7Net.getByteTransform().TransBool(result4.Content, 0, 1);
//                StaProtocol staProtocol = station.get(103);
//                staProtocol.setFrontErr(status[0]);
//                staProtocol.setBackErr(status[1]);
//                staProtocol.setHighErr(status[2]);
//                staProtocol.setLeftErr(status[3]);
//                staProtocol.setRightErr(status[4]);
//                staProtocol.setWeightErr(status[5]);
//                staProtocol.setBarcodeErr(status[6]);
//            }
//            // 外形检测 - 107
//            //Thread.sleep(50);
//            OperateResultExOne<byte[]> result5 = siemensS7Net.Read("DB101.164", (short)1);
//            if (result5.IsSuccess) {
//                boolean[] status = siemensS7Net.getByteTransform().TransBool(result5.Content, 0, 1);
//                StaProtocol staProtocol = station.get(107);
//                staProtocol.setFrontErr(status[0]);
//                staProtocol.setBackErr(status[1]);
//                staProtocol.setHighErr(status[2]);
//                staProtocol.setLeftErr(status[3]);
//                staProtocol.setRightErr(status[4]);
//                staProtocol.setWeightErr(status[5]);
//                staProtocol.setBarcodeErr(status[6]);
//            }
//            // 外形检测 - 111
//            //Thread.sleep(50);
//            OperateResultExOne<byte[]> result6 = siemensS7Net.Read("DB101.168", (short)1);
//            if (result6.IsSuccess) {
//                boolean[] status = siemensS7Net.getByteTransform().TransBool(result6.Content, 0, 1);
//                StaProtocol staProtocol = station.get(111);
//                staProtocol.setFrontErr(status[0]);
//                staProtocol.setBackErr(status[1]);
//                staProtocol.setHighErr(status[2]);
//                staProtocol.setLeftErr(status[3]);
//                staProtocol.setRightErr(status[4]);
//                staProtocol.setWeightErr(status[5]);
//                staProtocol.setBarcodeErr(status[6]);
//            }
//            // 外形检测 - 115
//            //Thread.sleep(50);
//            OperateResultExOne<byte[]> result7 = siemensS7Net.Read("DB101.172", (short)1);
//            if (result7.IsSuccess) {
//                boolean[] status = siemensS7Net.getByteTransform().TransBool(result7.Content, 0, 1);
//                StaProtocol staProtocol = station.get(115);
//                staProtocol.setFrontErr(status[0]);
//                staProtocol.setBackErr(status[1]);
//                staProtocol.setHighErr(status[2]);
//                staProtocol.setLeftErr(status[3]);
//                staProtocol.setRightErr(status[4]);
//                staProtocol.setWeightErr(status[5]);
//                staProtocol.setBarcodeErr(status[6]);
//            }
//            // 外形检测 - 119
//            //Thread.sleep(50);
//            OperateResultExOne<byte[]> result8 = siemensS7Net.Read("DB101.176", (short)1);
//            if (result8.IsSuccess) {
//                boolean[] status = siemensS7Net.getByteTransform().TransBool(result8.Content, 0, 1);
//                StaProtocol staProtocol = station.get(119);
//                staProtocol.setFrontErr(status[0]);
//                staProtocol.setBackErr(status[1]);
//                staProtocol.setHighErr(status[2]);
//                staProtocol.setLeftErr(status[3]);
//                staProtocol.setRightErr(status[4]);
//                staProtocol.setWeightErr(status[5]);
//                staProtocol.setBarcodeErr(status[6]);
//            }
//            // 外形检测 - 123
//            //Thread.sleep(50);
//            OperateResultExOne<byte[]> result9 = siemensS7Net.Read("DB101.180", (short)1);
//            if (result9.IsSuccess) {
//                boolean[] status = siemensS7Net.getByteTransform().TransBool(result9.Content, 0, 1);
//                StaProtocol staProtocol = station.get(123);
//                staProtocol.setFrontErr(status[0]);
//                staProtocol.setBackErr(status[1]);
//                staProtocol.setHighErr(status[2]);
//                staProtocol.setLeftErr(status[3]);
//                staProtocol.setRightErr(status[4]);
//                staProtocol.setWeightErr(status[5]);
//                staProtocol.setBarcodeErr(status[6]);
//            }
//        } else if (slave.getId() == 3) {
//            //条码
//            //Thread.sleep(200);
//            OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB101.18",(short)10);
//            if (result2.IsSuccess) {
//                    String barcode = siemensS7Net.getByteTransform().TransString(result2.Content,0,8, "UTF-8");
//                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, 7);
//                    if(!Cools.isEmpty(barcodeThread) && !barcodeThread.getBarcode().equals(barcode)) {
//                        barcodeThread.setBarcode(barcode);
//                    }
//            }
//            OperateResultExOne<byte[]> result10 = siemensS7Net.Read("DB101.26", (short)1);
//            if (result10.IsSuccess) {
//                boolean[] status = siemensS7Net.getByteTransform().TransBool(result10.Content, 0, 1);
//                StaProtocol staProtocol = station.get(301);
//                staProtocol.setFrontErr(status[0]);
//                staProtocol.setBackErr(status[1]);
//                staProtocol.setHighErr(status[2]);
//                staProtocol.setLeftErr(status[3]);
//                staProtocol.setRightErr(status[4]);
//                staProtocol.setWeightErr(status[5]);
//                staProtocol.setBarcodeErr(status[6]);
//            }
//        } else if (slave.getId() == 4) {
//            //条码
//            OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB101.18",(short)10);
//            if (result2.IsSuccess) {
//
//                String barcode = siemensS7Net.getByteTransform().TransString(result2.Content,0,8, "UTF-8");
//                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, 8);
//                if(!Cools.isEmpty(barcodeThread) && !barcodeThread.getBarcode().equals(barcode)) {
//                    barcodeThread.setBarcode(barcode);
//                }
//            }
//            // 外形检测 - 111
//            //Thread.sleep(50);
//            OperateResultExOne<byte[]> result10 = siemensS7Net.Read("DB101.26", (short)1);
//            if (result10.IsSuccess) {
//                boolean[] status = siemensS7Net.getByteTransform().TransBool(result10.Content, 0, 1);
//                StaProtocol staProtocol = station.get(401);
//                staProtocol.setFrontErr(status[0]);
//                staProtocol.setBackErr(status[1]);
//                staProtocol.setHighErr(status[2]);
//                staProtocol.setLeftErr(status[3]);
//                staProtocol.setRightErr(status[4]);
//                staProtocol.setWeightErr(status[5]);
//                staProtocol.setBarcodeErr(status[6]);
//
//            }
//        }
//
//
//        OperateResultExOne<byte[]> resultErr = siemensS7Net.Read("DB13.2", (short) (staNoSize*4));
//        if (resultErr.IsSuccess) {
//            for (int i = 0; i < staNoSize; i++) {
//                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.setOutTimeErr(status[2]);
//                staProtocol.setSeizeSeatErr(status[3]);
//                staProtocol.setWrkYgoodsN(status[4]);
//                staProtocol.setInverterErr(status[5]);
//                staProtocol.setContactErr(status[6]);
//                staProtocol.setUpcontactErr(status[7]);
//
//            }
//        }



@@ -433,7 +429,7 @@
//            this.ioMode = IoModeType.get(result2.Content);
//        }

        if (result.IsSuccess && result1.IsSuccess) {
        if (result.IsSuccess) {

            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));

@@ -470,220 +466,220 @@
     * 写入 ID+目标站 =====> 单站点写入
     */
    private void write(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;
        }
        ArrayList<Integer> staNos = getStaNo();

        int index = staNos.indexOf(staProtocol.getSiteId());
        short[] array = new short[2];
        array[0] = staProtocol.getWorkNo();
        array[1] = staProtocol.getStaNo();
//        OperateResult write = siemensS7Net.Write("DB100." + index*4, array);

        //更新命令日志
        CommandInfoLogService commandInfoLogService = SpringUtils.getBean(CommandInfoLogService.class);
        CommandInfoService commandInfoService = SpringUtils.getBean(CommandInfoService.class);
        CommandInfo commandInfo = commandInfoService.selectById(staProtocol.getCommandId());
        CommandInfoLog commandInfoLog = JSON.parseObject(JSON.toJSONString(commandInfo), CommandInfoLog.class);
        commandInfoLog.setId(null);
//        CommandInfoLog commandInfoLog = new CommandInfoLog();
//        if (commandInfo != null) {
//            commandInfoLog = JSON.parseObject(JSON.toJSONString(commandInfo), CommandInfoLog.class);
//            commandInfoLog.setId(null);
//        }else {
//            Date now = new Date();
//            commandInfoLog.setCommand(JSON.toJSONString(staProtocol));
//            commandInfoLog.setCommandStatus(3);
//            commandInfoLog.setStartTime(now);
//            commandInfoLog.setExecuteTime(now);
//            commandInfoLog.setCompleteTime(now);
//            commandInfoLog.setDevice(SlaveType.Devp.toString());
//            commandInfoLog.setWrkNo(9999);
//            commandInfoLog.setTaskNo("9999");
//            commandInfoLog.setCommandDesc("手动命令");
//        if (null == staProtocol) {
//            return;
//        }

        OperateResult writeResult;
        //任务下发次数
        int writeCount = 0;
        //任务下发成功标识
        boolean writeFlag = false;
        while(writeCount < 5){
            writeResult = siemensS7Net.Write("DB100." + index*4, array);    // 工作号、目标站

            if(writeResult.IsSuccess){
                Thread.sleep(200);
                OperateResultExOne<byte[]> readResult = siemensS7Net.Read("DB100." + index*4, (short)4);
                if(readResult.IsSuccess){
                    short workNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 0);
                    short staNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 2);
                    if(staProtocol.getWorkNo().equals(workNo) && staProtocol.getStaNo().equals(staNo)){
                        //任务命令写入成功
                        writeFlag = true;
                        log.info("写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);

                        Date now = new Date();

                        //更新指令状态
                        commandInfo.setCommandStatus(CommandStatusType.COMPLETE.id);//输送线直接完成状态
                        commandInfo.setExecuteTime(now);
                        commandInfo.setCompleteTime(now);
                        commandInfoService.updateById(commandInfo);

                        //更新指令日志
                        commandInfoLog.setDeviceLog("指令下发成功");
                        commandInfoLog.setCommandStatus(CommandStatusType.COMPLETE.id);//输送线直接完成状态
                        commandInfoLog.setExecuteTime(now);
                        commandInfoLog.setCompleteTime(now);
                        commandInfoLogService.insert(commandInfoLog);

                        //更新任务步序
                        TaskWrkService taskWrkService = SpringUtils.getBean(TaskWrkService.class);
                        TaskWrk taskWrk = taskWrkService.selectByWrkNo(staProtocol.getWorkNo().intValue());
                        if (taskWrk != null) {
                            taskWrk.setCommandStep(taskWrk.getCommandStep() + 1);//更新指令步序
                            taskWrkService.updateById(taskWrk);
                        }

                        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);
                        //更新指令日志
                        commandInfoLog.setDeviceLog("指令下发失败");
                        commandInfoLogService.insert(commandInfoLog);
                    }
                } 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);

                    //更新指令日志
                    commandInfoLog.setDeviceLog("指令下发失败");
                    commandInfoLogService.insert(commandInfoLog);
                }
            } 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);

                //更新指令日志
                commandInfoLog.setDeviceLog("指令下发失败");
                commandInfoLogService.insert(commandInfoLog);
            }
            Thread.sleep(200);
        }

        //写命令尝试了5次还是失败了
        if(!writeFlag){
            staProtocol = station.get(staProtocol.getSiteId());
            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
                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));

            //重新添加数据到任务队列
            boolean result = MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(2, staProtocol));
            read();//读取1次设备状态
            return;
        } else {
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】 输送线命令下发成功 [id:{1}] >>>>> {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(staProtocol)));
            //log.info("输送线命令下发 [id:{}] >>>>> 命令下发成功： {}",  slave.getId(), JSON.toJSON(staProtocol));

            Integer siteId = staProtocol.getSiteId();
            staProtocol = station.get(siteId);
            if ((siteId == 101 || siteId == 201)&&(staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0)) {
                staProtocol.setPakMk(true);
            }
        }
//        ArrayList<Integer> staNos = getStaNo();
//
//        int index = staNos.indexOf(staProtocol.getSiteId());
//        short[] array = new short[2];
//        array[0] = staProtocol.getWorkNo();
//        array[1] = staProtocol.getStaNo();
////        OperateResult write = siemensS7Net.Write("DB100." + index*4, array);
//
//        //更新命令日志
//        CommandInfoLogService commandInfoLogService = SpringUtils.getBean(CommandInfoLogService.class);
//        CommandInfoService commandInfoService = SpringUtils.getBean(CommandInfoService.class);
//        CommandInfo commandInfo = commandInfoService.selectById(staProtocol.getCommandId());
//        CommandInfoLog commandInfoLog = JSON.parseObject(JSON.toJSONString(commandInfo), CommandInfoLog.class);
//        commandInfoLog.setId(null);
////        CommandInfoLog commandInfoLog = new CommandInfoLog();
////        if (commandInfo != null) {
////            commandInfoLog = JSON.parseObject(JSON.toJSONString(commandInfo), CommandInfoLog.class);
////            commandInfoLog.setId(null);
////        }else {
////            Date now = new Date();
////            commandInfoLog.setCommand(JSON.toJSONString(staProtocol));
////            commandInfoLog.setCommandStatus(3);
////            commandInfoLog.setStartTime(now);
////            commandInfoLog.setExecuteTime(now);
////            commandInfoLog.setCompleteTime(now);
////            commandInfoLog.setDevice(SlaveType.Devp.toString());
////            commandInfoLog.setWrkNo(9999);
////            commandInfoLog.setTaskNo("9999");
////            commandInfoLog.setCommandDesc("手动命令");
////        }
//
//        OperateResult writeResult;
//        //任务下发次数
//        int writeCount = 0;
//        //任务下发成功标识
//        boolean writeFlag = false;
//        while(writeCount < 5){
//            writeResult = siemensS7Net.Write("DB100." + index*4, array);    // 工作号、目标站
//
//            if(writeResult.IsSuccess){
//                Thread.sleep(200);
//                OperateResultExOne<byte[]> readResult = siemensS7Net.Read("DB100." + index*4, (short)4);
//                if(readResult.IsSuccess){
//                    short workNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 0);
//                    short staNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 2);
//                    if(staProtocol.getWorkNo().equals(workNo) && staProtocol.getStaNo().equals(staNo)){
//                        //任务命令写入成功
//                        writeFlag = true;
//                        log.info("写入输送线命令后返回成功，并且回读成功。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
//
//                        Date now = new Date();
//
//                        //更新指令状态
//                        commandInfo.setCommandStatus(CommandStatusType.COMPLETE.id);//输送线直接完成状态
//                        commandInfo.setExecuteTime(now);
//                        commandInfo.setCompleteTime(now);
//                        commandInfoService.updateById(commandInfo);
//
//                        //更新指令日志
//                        commandInfoLog.setDeviceLog("指令下发成功");
//                        commandInfoLog.setCommandStatus(CommandStatusType.COMPLETE.id);//输送线直接完成状态
//                        commandInfoLog.setExecuteTime(now);
//                        commandInfoLog.setCompleteTime(now);
//                        commandInfoLogService.insert(commandInfoLog);
//
//                        //更新任务步序
//                        TaskWrkService taskWrkService = SpringUtils.getBean(TaskWrkService.class);
//                        TaskWrk taskWrk = taskWrkService.selectByWrkNo(staProtocol.getWorkNo().intValue());
//                        if (taskWrk != null) {
//                            taskWrk.setCommandStep(taskWrk.getCommandStep() + 1);//更新指令步序
//                            taskWrkService.updateById(taskWrk);
//                        }
//
//                        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);
//                        //更新指令日志
//                        commandInfoLog.setDeviceLog("指令下发失败");
//                        commandInfoLogService.insert(commandInfoLog);
//                    }
//                } 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);
//
//                    //更新指令日志
//                    commandInfoLog.setDeviceLog("指令下发失败");
//                    commandInfoLogService.insert(commandInfoLog);
//                }
//            } 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);
//
//                //更新指令日志
//                commandInfoLog.setDeviceLog("指令下发失败");
//                commandInfoLogService.insert(commandInfoLog);
//            }
//            Thread.sleep(200);
//        }
//
//        //写命令尝试了5次还是失败了
//        if(!writeFlag){
//            staProtocol = station.get(staProtocol.getSiteId());
//            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
//                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));
//
//            //重新添加数据到任务队列
//            boolean result = MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(2, staProtocol));
//            read();//读取1次设备状态
//            return;
//        } else {
//            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】 输送线命令下发成功 [id:{1}] >>>>> {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(staProtocol)));
//            //log.info("输送线命令下发 [id:{}] >>>>> 命令下发成功： {}",  slave.getId(), JSON.toJSON(staProtocol));
//
//            Integer siteId = staProtocol.getSiteId();
//            staProtocol = station.get(siteId);
//            if ((siteId == 101 || siteId == 201)&&(staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0)) {
//                staProtocol.setPakMk(true);
//            }
//        }

    }
    private void write2(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;
        }
        ArrayList<Integer> staNos = getStaNo();

        int index = staNos.indexOf(staProtocol.getSiteId());
        short[] array = new short[2];
        array[0] = staProtocol.getWorkNo();
        array[1] = staProtocol.getStaNo();

        OperateResult writeResult;
        //任务下发次数
        int writeCount = 0;
        //任务下发成功标识
        boolean writeFlag = false;
        while(writeCount < 5){
            writeResult = siemensS7Net.Write("DB100." + index*4, array);    // 工作号、目标站

            if(writeResult.IsSuccess){
                Thread.sleep(200);
                OperateResultExOne<byte[]> readResult = siemensS7Net.Read("DB100." + index*4, (short)4);
                if(readResult.IsSuccess){
                    short workNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 0);
                    short staNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 2);
                    if(staProtocol.getWorkNo().equals(workNo) && staProtocol.getStaNo().equals(staNo)){
                        //任务命令写入成功
                        writeFlag = true;
                        log.info("写入输送线命令后返回成功，并且回读成功。输送线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);

                    }
                } 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);

                }
            } 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);

            }
            Thread.sleep(200);
        }

        //写命令尝试了5次还是失败了
        if(!writeFlag){
            staProtocol = station.get(staProtocol.getSiteId());
            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
                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));

            //重新添加数据到任务队列
            boolean result = MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(3, staProtocol));
            read();//读取1次设备状态
            return;
        } else {
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】 输送线命令下发成功 [id:{1}] >>>>> {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(staProtocol)));
            //log.info("输送线命令下发 [id:{}] >>>>> 命令下发成功： {}",  slave.getId(), JSON.toJSON(staProtocol));

            Integer siteId = staProtocol.getSiteId();
            staProtocol = station.get(siteId);
            if ((siteId == 101 || siteId == 201)&&(staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0)) {
                staProtocol.setPakMk(true);
            }

        }
//        if (null == staProtocol) {
//            return;
//        }
//        ArrayList<Integer> staNos = getStaNo();
//
//        int index = staNos.indexOf(staProtocol.getSiteId());
//        short[] array = new short[2];
//        array[0] = staProtocol.getWorkNo();
//        array[1] = staProtocol.getStaNo();
//
//        OperateResult writeResult;
//        //任务下发次数
//        int writeCount = 0;
//        //任务下发成功标识
//        boolean writeFlag = false;
//        while(writeCount < 5){
//            writeResult = siemensS7Net.Write("DB100." + index*4, array);    // 工作号、目标站
//
//            if(writeResult.IsSuccess){
//                Thread.sleep(200);
//                OperateResultExOne<byte[]> readResult = siemensS7Net.Read("DB100." + index*4, (short)4);
//                if(readResult.IsSuccess){
//                    short workNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 0);
//                    short staNo = siemensS7Net.getByteTransform().TransInt16(readResult.Content, 2);
//                    if(staProtocol.getWorkNo().equals(workNo) && staProtocol.getStaNo().equals(staNo)){
//                        //任务命令写入成功
//                        writeFlag = true;
//                        log.info("写入输送线命令后返回成功，并且回读成功。输送线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);
//
//                    }
//                } 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);
//
//                }
//            } 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);
//
//            }
//            Thread.sleep(200);
//        }
//
//        //写命令尝试了5次还是失败了
//        if(!writeFlag){
//            staProtocol = station.get(staProtocol.getSiteId());
//            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
//                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));
//
//            //重新添加数据到任务队列
//            boolean result = MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(3, staProtocol));
//            read();//读取1次设备状态
//            return;
//        } else {
//            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】 输送线命令下发成功 [id:{1}] >>>>> {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(staProtocol)));
//            //log.info("输送线命令下发 [id:{}] >>>>> 命令下发成功： {}",  slave.getId(), JSON.toJSON(staProtocol));
//
//            Integer siteId = staProtocol.getSiteId();
//            staProtocol = station.get(siteId);
//            if ((siteId == 101 || siteId == 201)&&(staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0)) {
//                staProtocol.setPakMk(true);
//            }
//
//        }

    }


 src/main/resources/application-prod.yml

@@ -218,145 +218,10 @@
      devpPlcId: ${wcs-slave.devp[1].id}
  devp[0]: #输送线
    id: 1
    ip: 172.17.91.36
    ip: 192.168.10.10
    rack: 0
    port: 102
    slot: 0
    emptyInSta[0]: #空板入库口0
      staNo: 103
    emptyInSta[1]: #空板入库口1
      staNo: 105
    emptyInSta[2]: #空板入库口2
      staNo: 109
    emptyInSta[3]: #空板入库口3
      staNo: 113
    emptyInSta[4]: #空板入库口4
      staNo: 117
    emptyInSta[5]: #空板入库口5
      staNo: 121
    inSta[0]: #入库口1
      #scale: ${wcs-slave.scale[0].id}
      staNo: 103
      backSta: 102
      barcode: ${wcs-slave.barcode[0].id}
    inSta[1]: #入库口2
      #scale: ${wcs-slave.scale[1].id}
      staNo: 107
      backSta: 106
      barcode: ${wcs-slave.barcode[1].id}
      #slot: 0
    inSta[2]: #入库口1
      #scale: ${wcs-slave.scale[0].id}
      staNo: 111
      backSta: 110
      barcode: ${wcs-slave.barcode[2].id}
    inSta[3]: #入库口1
      #scale: ${wcs-slave.scale[0].id}
      staNo: 115
      backSta: 114
      barcode: ${wcs-slave.barcode[3].id}
    inSta[4]: #入库口2
      #scale: ${wcs-slave.scale[1].id}
      staNo: 119
      backSta: 118
      barcode: ${wcs-slave.barcode[4].id}
      #slot: 0
    inSta[5]: #入库口1
      #scale: ${wcs-slave.scale[0].id}
      staNo: 123
      backSta: 122
      barcode: ${wcs-slave.barcode[5].id}
    outSta[0]: #出库口1
      staNo: 100
    outSta[1]: #出库口2
      staNo: 104
    outSta[2]: #出库口2
      staNo: 108
    outSta[3]: #出库口1
      staNo: 112
    outSta[4]: #出库口2
      staNo: 116
    outSta[5]: #出库口2
      staNo: 120
  devp[1]: #输送线
    id: 2
    ip: 172.17.91.45
    rack: 0
    port: 102
    slot: 0
    inSta[0]: #入库口2
      #scale: ${wcs-slave.scale[1].id}
      staNo: 205
      backSta: 203
      #barcode: ${wcs-slave.barcode[4].id}
    inSta[1]: #入库口2
      #scale: ${wcs-slave.scale[1].id}
      staNo: 211
      backSta: 209
      #barcode: ${wcs-slave.barcode[4].id}
    inSta[2]: #入库口2
      #scale: ${wcs-slave.scale[1].id}
      staNo: 217
      backSta: 215
      #barcode: ${wcs-slave.barcode[4].id}
    inSta[3]: #入库口2
      #scale: ${wcs-slave.scale[1].id}
      staNo: 223
      backSta: 221
      #barcode: ${wcs-slave.barcode[4].id}
    inSta[4]: #入库口2
      #scale: ${wcs-slave.scale[1].id}
      staNo: 229
      backSta: 227
      #barcode: ${wcs-slave.barcode[4].id}
    inSta[5]: #入库口2
      #scale: ${wcs-slave.scale[1].id}
      staNo: 235
      backSta: 232
      #barcode: ${wcs-slave.barcode[4].id}
    outSta[0]: #出库口1
      staNo: 200
    outSta[1]: #出库口1
      staNo: 206
    outSta[2]: #出库口1
      staNo: 212
    outSta[3]: #出库口1
      staNo: 218
    outSta[4]: #出库口1
      staNo: 224
    outSta[5]: #出库口1
      staNo: 230
  devp[2]: #输送线
    id: 3
    ip: 172.17.8.201
    rack: 0
    slot: 0
    port: 102
    emptyInSta[0]: #空板入库口1
      staNo: 306
    inSta[0]: #入库口1
      scale: ${wcs-slave.scale[1].id}
      staNo: 301
      barcode: ${wcs-slave.barcode[6].id}
      backSta: 300
      #slot: 0
    outSta[0]: #出库口1
      staNo: 307
  devp[3]: #输送线
    id: 4
    ip: 172.17.7.201
    rack: 0
    slot: 0
    port: 102
    emptyInSta[0]: #空板入库口1
      staNo: 406
    inSta[0]: #入库口1
      scale: ${wcs-slave.scale[1].id}
      staNo: 401
      barcode: ${wcs-slave.barcode[7].id}
      backSta: 400
    outSta[0]: #出库口1
      staNo: 407
  scale[0]: #磅秤
    port: 5005
    ip: 10.10.10.201