*

lsh

2024-10-16 b86abab05ca255309bc1defe3a4969032c983891

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

@@ -46,6 +46,7 @@
    public boolean charge0;     //请求充电
    public boolean charge1;     //请求充电
    private short heartBeatVal = 1;
    private boolean result = false;
    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);
@@ -183,30 +184,6 @@
                    case 2:
                        write((StaProtocol)task.getData());
                        break;
                    // 写数据 ID+目标站 码垛完成  给输送线写任务完成
                    case 3:
                        write3((StaProtocol)task.getData());
                        break;
                    // 写数据 ID+目标站 码垛完成  给输送线写任务完成复位
                    case 4:
                        write4((StaProtocol)task.getData());
                        break;
                    case 5:
                        write3((StaProtocol)task.getData());
                        Thread.sleep(400);
                        write4((StaProtocol)task.getData());
                        Thread.sleep(400);
                        write((StaProtocol)task.getData());
                        break;
                    case 9:
                        write9((StaProtocol)task.getData());
                        break;
                    case 10:
                        write10((StaProtocol)task.getData());
                        break;
                    case 11:
                        write11((StaProtocol)task.getData());
                        break;
                    default:
                        break;
                }
@@ -222,7 +199,7 @@

    @Override
    public boolean connect() {
        boolean result = false;
        result = false;
        siemensS7Net = new SiemensS7Net(SiemensPLCS.S1200, slave.getIp());
        siemensS7Net.setRack(slave.getRack().byteValue());
        siemensS7Net.setSlot(slave.getSlot().byteValue());
@@ -243,8 +220,6 @@
     * 读取状态 ====> 整块plc
     */
    private void read() throws InterruptedException {
//        // 更新入出库模式
//        updateIoMode();
        ArrayList<Integer> staNos = getStaNo();
        int staNoSize = staNos.size();
        OperateResultExOne<byte[]> result = siemensS7Net.Read("DB101.0", (short) (staNoSize*8));
@@ -300,91 +275,6 @@
            }
        }

        if (slave.getId()==2){
            Thread.sleep(200);
            int[] staNosRgv = {623,624,625,626};
            for (int i = 0; i < staNosRgv.length; i++) {
                OperateResultExOne<byte[]> resultRgv = siemensS7Net.Read("DB100."+(1800+i*6), (short) 5);
                OperateResultExOne<byte[]> resultRgv2 = siemensS7Net.Read("DB100."+(1824+i*12), (short) 8);
                if (resultRgv.IsSuccess) {
                    Integer siteId = staNosRgv[i]; // 站点编号
                    StaProtocol staProtocol = station.get(siteId);
                    if (null == staProtocol) {
                        staProtocol = new StaProtocol();
                        staProtocol.setSiteId(siteId);
                        station.put(siteId, staProtocol);
                    }
                    try{
                        staProtocol.setEndRow(siemensS7Net.getByteTransform().TransInt16(resultRgv2.Content, 0));     // 小车目标位

                        staProtocol.setNowRow(siemensS7Net.getByteTransform().TransInt16(resultRgv.Content, 2));   // 当前位置

                        boolean[] status = siemensS7Net.getByteTransform().TransBool(resultRgv.Content, 4, 1);
                        staProtocol.setRGV1(status[0]);  // 小车无货空闲
                        staProtocol.setRGV2(status[1]);  // 小车输送线取货到位
                        staProtocol.setRGV3(status[2]); // 小车运行中

//                        staProtocol.setRGV1(false);  // 小车无货空闲
//                        staProtocol.setRGV2(true);  // 小车输送线取货到位
//                        staProtocol.setRGV3(false); // 小车运行中

                        staProtocol.setRGV44(siemensS7Net.getByteTransform().TransInt16(resultRgv2.Content, 2));//小车改左侧货物目标站
                        staProtocol.setRGV55(siemensS7Net.getByteTransform().TransInt16(resultRgv2.Content, 4));  //小车改右侧货物目标站
                        staProtocol.setRGV66(siemensS7Net.getByteTransform().TransInt16(resultRgv2.Content, 6));  // 上位机清除平移车资料
//
//                        staProtocol.setRGV44((short) 0);//小车改左侧货物目标站
//                        staProtocol.setRGV55((short) 0);  //小车改右侧货物目标站
//                        staProtocol.setRGV66((short) 0);  // 上位机清除平移车资料

                        staProtocol.setRGV4(staProtocol.getRGV44() != 0 && staProtocol.getRGV44() != 2);//小车改左侧货物目标站
                        staProtocol.setRGV5(staProtocol.getRGV55() != 0 && staProtocol.getRGV55() != 2);  //小车改右侧货物目标站
                        staProtocol.setRGV6(staProtocol.getRGV66() != 0 && staProtocol.getRGV66() != 2);  // 上位机清除平移车资料


                    }catch (Exception e){
                        log.error("读取RGV信息失败"+e.getMessage());
                    }
                }
            }
        }


        //条码扫描器
        Thread.sleep(200);
        OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB101.2440",(short)(barcodeSize*8));
        if (result2.IsSuccess) {
            int[] staNosRgv = {281,292,173,214,120};

            for (int i = 0; i < barcodeSize; i++) {  //1:281  2:292  3:174(173) 4:214  5:120
                String barcode = siemensS7Net.getByteTransform().TransString(result2.Content,i*8,8, "UTF-8");
                BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, i + 1);
                if(!Cools.isEmpty(barcodeThread) && !barcodeThread.getBarcode().equals(barcode)) {
                    Integer siteId = staNosRgv[i]; // 站点编号
                    StaProtocol staProtocol = station.get(siteId);
                    if (null == staProtocol) {
                        staProtocol = new StaProtocol();
                        staProtocol.setSiteId(siteId);
                        station.put(siteId, staProtocol);
                    }
                    staProtocol.setBarcode(barcode);
                    barcodeThread.setBarcode(barcode);
                }
            }
        }

        //RGV小车
        Thread.sleep(200);
        OperateResultExOne<byte[]> result3 = siemensS7Net.Read("DB100.160",(short)2);
        if (result3.IsSuccess) {
            Integer siteId = 2000;
            StaProtocol staProtocol = station.get(siteId);
            if (null == staProtocol) {
                staProtocol = new StaProtocol();
                staProtocol.setSiteId(siteId);
                station.put(siteId, staProtocol);
            }
            staProtocol.setNearbySta(String.valueOf(siemensS7Net.getByteTransform().TransInt16(result3.Content, 0)));
        }

        if (result.IsSuccess) {

@@ -398,9 +288,13 @@
                    basDevps.add(staProtocol.toSqlModel());
                }

                BasDevpService basDevpService = SpringUtils.getBean(BasDevpService.class);
                if (null != basDevpService && !basDevpService.updateBatchById(basDevps)) {
                    throw new Exception("更新数据库数据失败");
                try{
                    BasDevpService basDevpService = SpringUtils.getBean(BasDevpService.class);
                    if (null != basDevpService && !basDevpService.updateBatchById(basDevps)) {
                        throw new Exception("更新数据库数据失败");
                    }
                } catch (Exception e){
                    log.error("更新数据库数据失败 ===>> [id:{}] [ip:{}] [port:{}] [rack:{}] [slot:{}]", slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot());
                }
            } catch (Exception e) {
                e.printStackTrace();
@@ -433,9 +327,9 @@
        //任务下发次数
        int writeCount = 0;
        do {
            write = siemensS7Net.Write("DB100." + index*6, staProtocol.getWorkNo());    // 工作号
            Thread.sleep(500);
            write1 = siemensS7Net.Write("DB100." + (index*6+4), staProtocol.getStaNo().shortValue());    // 目标站
//            Thread.sleep(500);
            write = siemensS7Net.Write("DB100." + index*6, staProtocol.getWorkNo());    // 工作号
            if(write.IsSuccess || write1.IsSuccess){
                writeCount=6;
            }else {
@@ -454,531 +348,6 @@
        } 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));
        }
    }


    /**
     * 写入 ID+目标站 =====> 单站点写入   码垛完成  给输送线写任务完成
     */
    private void write3(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;
        }
        Integer siteId = staProtocol.getSiteId();
        Integer index =0;
        switch (siteId){
            case 118:
                index=0;
                break;
            case 119:
                index=1;
                break;
            case 120:
                index=2;
                break;
            case 121:
                index=3;
                break;
            case 131:
                index=4;
                break;
            case 135:
                index=5;
                break;
            case 147:
                index=6;
                break;
            default:
                return;
        }

        OperateResult write = null;
        //任务下发次数
        int writeCount = 0;
        do {
            write = siemensS7Net.Write("DB100.600." + index, true);    // 任务完成
            if(write.IsSuccess){
                writeCount=6;
            }else {
                writeCount++;
                log.error("写入输送线命令后读取失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
            }
        }while (writeCount<5);

        if (!write.IsSuccess) {
            staProtocol = station.get(staProtocol.getSiteId());
            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
                staProtocol.setPakMk(true);
            }
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线站点数据失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(staProtocol)));
            log.error("写入输送线站点数据失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));
        } 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));
        }
    }

    private void write4(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;
        }
        Integer siteId = staProtocol.getSiteId();
        Integer index =0;
        switch (siteId){
            case 118:
                index=0;
                break;
            case 119:
                index=1;
                break;
            case 120:
                index=2;
                break;
            case 121:
                index=3;
                break;
            case 131:
                index=4;
                break;
            case 135:
                index=5;
                break;
            case 147:
                index=6;
                break;
            default:
                return;
        }

        OperateResult write = null;
        //任务下发次数
        int writeCount = 0;
        do {
            write = siemensS7Net.Write("DB100.600." + index, false);    // 任务完成复位
            if(write.IsSuccess){
                writeCount=6;
            }else {
                writeCount++;
                log.error("写入输送线命令后读取失败。输送线plc编号={}，站点数据={},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), writeCount);
            }
        }while (writeCount<5);

        if (!write.IsSuccess) {
            staProtocol = station.get(staProtocol.getSiteId());
            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
                staProtocol.setPakMk(true);
            }
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线站点数据失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(staProtocol)));
            log.error("写入输送线站点数据失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));
        } 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.toJSONString(staProtocol));
        }
    }

    /**
     * 写入 ID+目标站 =====> 单站点写入
     */
    private void write11(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;
        }
        News.error("RGV写入命令"+JSON.toJSONString(staProtocol));

        boolean rgv6 = staProtocol.isRGV6();
        OperateResult result1 = null;
        OperateResult result2 = null;
        String resultV1 = "";
        String resultV2 = "";
        String resultV3 = "";
        short resultS1 = 1;
        short resultS2 = 2;
        switch (staProtocol.getSiteId()){
            case 623:
                resultV1 = "DB100.1830";
                resultV2 = "DB100.1826";
                resultV3 = "DB100.1828";
                break;
            case 624:
                resultV1 = "DB100.1842";
                resultV2 = "DB100.1838";
                resultV3 = "DB100.1840";
                break;
            case 625:
                resultV1 = "DB100.1854";
                resultV2 = "DB100.1850";
                resultV3 = "DB100.1852";
                break;
            case 626:
                resultV1 = "DB100.1866";
                resultV2 = "DB100.1862";
                resultV3 = "DB100.1864";
                break;
            default:
                return;
        }
        siemensS7Net.Write(resultV2, (short) 0);
        siemensS7Net.Write(resultV3, (short) 0);
        result1 = siemensS7Net.Write(resultV1, resultS1);

        //硫化罐任务写入后，回读一次，看是否成功
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        int writeCount = 1;
        do {
            try{
                if(!result1.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(resultV1, resultS1);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
                OperateResultExOne<byte[]> resultRead1 = siemensS7Net.Read(resultV1, (short) 2);
                if (resultRead1.IsSuccess) {
                    short status = siemensS7Net.getByteTransform().TransInt16(resultRead1.Content, 0);
                    if (status == 1){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                        result1 = siemensS7Net.Write(resultV1, resultS1);
                        Thread.sleep(100);
                        writeCount++;
                        continue;
                    }
                } else {
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(resultV1, resultS1);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
            }catch (Exception e){
                log.error("写入RGV数据后回读出错,异常："+e);
            }
            writeCount++;
        } while (writeCount<6);

        result2 = siemensS7Net.Write(resultV1, resultS2);

        //硫化罐任务写入后，回读一次，看是否成功
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        writeCount = 1;
        do {
            try{
                if(!result2.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV1, resultS2);

                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
                OperateResultExOne<byte[]> resultRead1 = siemensS7Net.Read(resultV1, (short) 2);
                if (resultRead1.IsSuccess) {
                    short status = siemensS7Net.getByteTransform().TransInt16(resultRead1.Content, 0);
                    if (status == resultS2){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                        result2 = siemensS7Net.Write(resultV1, resultS2);
                        Thread.sleep(100);
                        writeCount++;
                        continue;
                    }
                } else {
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV1, resultS2);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
            }catch (Exception e){
                log.error("写入RGV数据后回读出错,异常："+e);
            }
            writeCount++;
        } while (writeCount<6);
    }

    private void write10(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;
        }
        News.error("RGV写入命令"+JSON.toJSONString(staProtocol));

        boolean rgv4 = staProtocol.isRGV4();
        boolean rgv5 = staProtocol.isRGV5();
        OperateResult result1 = null;
        OperateResult result2 = null;
        String resultV1 = "";
        String resultV2 = "";
        short resultS1 = 1;
        short resultS2 = 2;
        if (rgv4){
            switch (staProtocol.getSiteId()){
                case 623:
                    resultV1 = "DB100.1826";
                    resultV2 = "DB100.1830";
                    break;
                case 624:
                    resultV1 = "DB100.1838";
                    resultV2 = "DB100.1842";
                    break;
                case 625:
                    resultV1 = "DB100.1850";
                    resultV2 = "DB100.1854";
                    break;
                case 626:
                    resultV1 = "DB100.1862";
                    resultV2 = "DB100.1866";
                    break;
                default:
                    return;
            }
        } else if (rgv5){
            switch (staProtocol.getSiteId()){
                case 623:
                    resultV1 = "DB100.1828";
                    resultV2 = "DB100.1830";
                    break;
                case 624:
                    resultV1 = "DB100.1840";
                    resultV2 = "DB100.1842";
                    break;
                case 625:
                    resultV1 = "DB100.1852";
                    resultV2 = "DB100.1854";
                    break;
                case 626:
                    resultV1 = "DB100.1864";
                    resultV2 = "DB100.1866";
                    break;
                default:
                    return;
            }
        }
        siemensS7Net.Write(resultV2, (short) 0);
        result1 = siemensS7Net.Write(resultV1, resultS1);
        //硫化罐任务写入后，回读一次，看是否成功
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        int writeCount = 1;
        do {
            try{
                if(!result1.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(resultV1, resultS1);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
                OperateResultExOne<byte[]> resultRead1 = siemensS7Net.Read(resultV1, (short) 2);
                if (resultRead1.IsSuccess) {
//                    boolean[] status = siemensS7Net.getByteTransform().TransBool(resultRead1.Content, 0, 1);
                    short statusR1 = siemensS7Net.getByteTransform().TransInt16(resultRead1.Content, 0);
                    if (statusR1 == resultS1){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                        result1 = siemensS7Net.Write(resultV1, resultS1);
                        Thread.sleep(100);
                        writeCount++;
                        continue;
                    }
                } else {
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(resultV1, resultS1);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
            }catch (Exception e){
                log.error("写入RGV数据后回读出错,异常："+e);
            }
            writeCount++;
        } while (writeCount<6);


        result2 = siemensS7Net.Write(resultV1, resultS2);

        writeCount = 1;
        do {
            try{
                if(!result2.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV1, resultS2);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
                OperateResultExOne<byte[]> resultRead1 = siemensS7Net.Read(resultV1, (short) 2);
                if (resultRead1.IsSuccess) {
//                    boolean[] status = siemensS7Net.getByteTransform().TransBool(resultRead1.Content, 0, 1);
                    short statusR1 = siemensS7Net.getByteTransform().TransInt16(resultRead1.Content, 0);
                    if (statusR1 == resultS2){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                        result2 = siemensS7Net.Write(resultV1, resultS2);

                        Thread.sleep(100);
                        writeCount++;
                        continue;
                    }
                } else {
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV1, resultS2);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
            }catch (Exception e){
                log.error("写入RGV数据后回读出错,异常："+e);
            }
            writeCount++;
        } while (writeCount<6);
    }

    private void write9(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;
        }
        short resultS1 = staProtocol.getEndRow();
        OperateResult result1 = null;
        OperateResult result2 = null;
        String resultV1 = "";
        String resultV2 = "";
        News.error("RGV写入命令"+JSON.toJSONString(staProtocol));

        switch (staProtocol.getSiteId()){
            case 623:
                resultV1 = "DB100.1824";
                resultV2 = "DB100.1848";
                break;
            case 624:
                resultV1 = "DB100.1836";
                resultV2 = "DB100.1860";
                break;
            case 625:
                resultV1 = "DB100.1848";
                resultV2 = "DB100.1824";
                break;
            case 626:
                resultV1 = "DB100.1860";
                resultV2 = "DB100.1836";
                break;
            default:
                return;
        }
        result1 = siemensS7Net.Write(resultV1, resultS1);
        result2 = siemensS7Net.Write(resultV2, resultS1);
        //硫化罐任务写入后，回读一次，看是否成功
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        int writeCount = 1;
        do {
            try{
                if(!result1.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(resultV1, resultS1);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
                OperateResultExOne<byte[]> resultRead1 = siemensS7Net.Read(resultV1, (short) 2);
                if (resultRead1.IsSuccess) {
                    short transInt16 = siemensS7Net.getByteTransform().TransInt16(resultRead1.Content, 0);
                    if (transInt16 == resultS1){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                        result1 = siemensS7Net.Write(resultV1, resultS1);
                        Thread.sleep(100);
                        writeCount++;
                        continue;
                    }
                } else {
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(resultV1, resultS1);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
            }catch (Exception e){
                log.error("写入RGV数据后回读出错,异常："+e);
            }
            writeCount++;
        } while (writeCount<6);

        writeCount = 1;
        do {
            try{
                if(!result2.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV2, resultS1);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
                OperateResultExOne<byte[]> resultRead2 = siemensS7Net.Read(resultV2, (short) 2);
                if (resultRead2.IsSuccess) {
                    short transInt16 = siemensS7Net.getByteTransform().TransInt16(resultRead2.Content, 0);
                    if (transInt16 == resultS1){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                        result2 = siemensS7Net.Write(resultV2, resultS1);
                        Thread.sleep(100);
                        writeCount++;
                        continue;
                    }
                } else {
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV2, resultS1);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
            }catch (Exception e){
                log.error("写入RGV数据后回读出错,异常："+e);
            }
            writeCount++;
        } while (writeCount<6);

        if (!result1.IsSuccess) {
            staProtocol = station.get(staProtocol.getSiteId());
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线站点数据失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSONString(staProtocol)));
            log.error("写入输送线站点数据失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSONString(staProtocol));
        } else {
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】 输送线命令下发 [id:{1}] >>>>> {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSONString(staProtocol)));
            log.info("输送线命令下发完成  给输送复位 [id:{}] >>>>> 命令下发： {}",  slave.getId(), JSON.toJSONString(staProtocol));
        }
    }

    // 更新入出库模式
    private void updateIoMode() throws InterruptedException {
        if (this.ioModeOf2F != IoModeType.NONE) {
            if (!siemensS7Net.Write("DB100.180", this.ioModeOf2F.id).IsSuccess) {
                OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线2F入出库模式失败。输送线plc编号={1}", slave.getId()));
                log.error("写入输送线2F入出库模式失败。输送线plc编号={}", slave.getId());
            }
        }
    }

@@ -1014,37 +383,8 @@
    }

    public static void main(String[] args) {
        System.out.println(staNos1.indexOf(129));
        System.out.println(staNos1.size());
        for (int i = 0; i<staNos1.size(); i++) {
//            System.out.println(i*2);
//            System.out.println(i*2 + 200);
//            System.out.println(i);
        }
        int index = staNos1.indexOf(128);
        System.out.println(index*2);
        System.out.println(index*2 + 200);

    }

//    public static void main(String[] args) throws Exception {
//        DevpSlave slave = new DevpSlave();
//        slave.setIp("192.168.2.125");
//        SiemensDevpThread devpThread = new SiemensDevpThread(slave);
//        devpThread.connect();
//        devpThread.read();
//        // 写
//        StaProtocol staProtocol = devpThread.getStation().get(1);
//        staProtocol.setWorkNo((short) 232);
//        staProtocol.setStaNo((short) 6);
//        staProtocol.setAutoing(true);
//        staProtocol.setEmptyMk(true);
//        staProtocol.setInEnable(true);
//        devpThread.write(staProtocol);
//        System.out.println("----------------------------------------");
//        // 读
//        devpThread.read();
//        System.out.println(JSON.toJSONString(devpThread.station));
//
//    }

}