#

lsh

2024-07-11 1e5df4a2e55d8fb959311c5da8a1be183adbcd8b

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

@@ -12,6 +12,7 @@
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.service.BasDevpService;
import com.zy.core.DevpThread;
import com.zy.core.News;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.OutputQueue;
import com.zy.core.cache.SlaveConnection;
@@ -200,6 +201,12 @@
                    case 9:
                        write9((StaProtocol)task.getData());
                        break;
                    case 10:
                        write10((StaProtocol)task.getData());
                        break;
                    case 11:
                        write11((StaProtocol)task.getData());
                        break;
                    default:
                        break;
                }
@@ -298,28 +305,42 @@
            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);
                        continue;
                    }
                    try{
                        staProtocol.setEndRow(siemensS7Net.getByteTransform().TransInt16(resultRgv.Content, 0));     // 小车目标位
                        staProtocol.setEndRow(siemensS7Net.getByteTransform().TransInt16(resultRgv2.Content, 0));     // 小车目标位

                        staProtocol.setNowRow(siemensS7Net.getByteTransform().TransInt16(resultRgv.Content, 2));   // 目标站
                        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.setRGV4(status[3]);//
                        staProtocol.setRGV5(status[4]);  //
                        staProtocol.setRGV6(status[5]);  // 满托盘
                        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){
                        System.out.println(e.getMessage());
                        log.error("读取RGV信息失败"+e.getMessage());
                    }
                }
            }
@@ -328,12 +349,20 @@

        //条码扫描器
        Thread.sleep(200);
        OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB101.840",(short)(barcodeSize*8));
        OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB101.2440",(short)(barcodeSize*8));
        if (result2.IsSuccess) {
            for (int i = 0; i < barcodeSize; i++) {  //1:217  2:221  3:null 4:215  5:219
                String barcode = siemensS7Net.getByteTransform().TransString(result2.Content,i*8,6, "UTF-8");
            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) {
                        continue;
                    }
                    staProtocol.setBarcode(barcode);
                    barcodeThread.setBarcode(barcode);
                }
            }
@@ -540,44 +569,55 @@
            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));
            log.info("输送线命令下发完成  给输送复位 [id:{}] >>>>> 命令下发： {}",  slave.getId(), JSON.toJSONString(staProtocol));
        }
    }

    /**
     * 写入 ID+目标站 =====> 单站点写入
     */
    private void write10(StaProtocol staProtocol) throws InterruptedException {
    private void write11(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;
        }
        boolean rgv4 = staProtocol.isRGV4();
        boolean rgv5 = staProtocol.isRGV5();
        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 = "1804";
                resultV2 = "1804";
                resultV1 = "DB100.1830";
                resultV2 = "DB100.1826";
                resultV3 = "DB100.1828";
                break;
            case 624:
                resultV1 = "1810";
                resultV2 = "1810";
                resultV1 = "DB100.1842";
                resultV2 = "DB100.1838";
                resultV3 = "DB100.1840";
                break;
            case 625:
                resultV1 = "1816";
                resultV2 = "1816";
                resultV1 = "DB100.1854";
                resultV2 = "DB100.1850";
                resultV3 = "DB100.1852";
                break;
            case 626:
                resultV1 = "1822";
                resultV2 = "1822";
                resultV1 = "DB100.1866";
                resultV2 = "DB100.1862";
                resultV3 = "DB100.1864";
                break;
            default:
                return;
        }
        result1 = siemensS7Net.Write(rgv4?resultV1+".4":resultV1+".3", rgv4?rgv5:rgv4);
        siemensS7Net.Write(resultV2, (short) 0);
        siemensS7Net.Write(resultV3, (short) 0);
        result1 = siemensS7Net.Write(resultV1, resultS1);

        //硫化罐任务写入后，回读一次，看是否成功
        try {
            Thread.sleep(200);
@@ -589,28 +629,27 @@
        do {
            try{
                if(!result1.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(rgv4?resultV1+".4":resultV1+".3", rgv4?rgv5:rgv4);
                    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);
                    boolean status1 = status[rgv4? 4:3];
                    if (status1 == rgv4?rgv5:rgv4){
                    short status = siemensS7Net.getByteTransform().TransInt16(resultRead1.Content, 0);
                    if (status == 1){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                        result1 = siemensS7Net.Write(rgv4?resultV1+".4":resultV1+".3", rgv4?rgv5:rgv4);
                        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.toJSON(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(rgv4?resultV1+".4":resultV1+".3", rgv4?rgv5:rgv4);
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(resultV1, resultS1);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
@@ -621,33 +660,41 @@
            writeCount++;
        } while (writeCount<6);

        result2 = siemensS7Net.Write(rgv4?resultV2+".3":resultV2+".4", rgv4?rgv4:rgv5);
        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.toJSON(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(rgv4?resultV2+".3":resultV2+".4", rgv4?rgv4:rgv5);
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV1, resultS2);

                    Thread.sleep(100);
                    writeCount++;
                    continue;
                }
                OperateResultExOne<byte[]> resultRead2 = siemensS7Net.Read(resultV2, (short) 1);
                if (resultRead2.IsSuccess) {
                    boolean[] status = siemensS7Net.getByteTransform().TransBool(resultRead2.Content, 0, 1);
                    boolean status1 = status[rgv4? 3:4];
                    if (status1 ==  rgv4?rgv4:rgv5){
                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.toJSON(staProtocol),writeCount);
                        result2 = siemensS7Net.Write(rgv4?resultV2+".3":resultV2+".4", rgv4?rgv4:rgv5);
                        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.toJSON(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(rgv4?resultV2+".3":resultV2+".4", rgv4?rgv4:rgv5);
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV1, resultS2);
                    Thread.sleep(100);
                    writeCount++;
                    continue;
@@ -658,6 +705,149 @@
            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;
@@ -667,22 +857,24 @@
        OperateResult result2 = null;
        String resultV1 = "";
        String resultV2 = "";
        News.error("RGV写入命令"+JSON.toJSONString(staProtocol));

        switch (staProtocol.getSiteId()){
            case 623:
                resultV1 = "1800";
                resultV2 = "1812";
                resultV1 = "DB100.1824";
                resultV2 = "DB100.1848";
                break;
            case 624:
                resultV1 = "1806";
                resultV2 = "1818";
                resultV1 = "DB100.1836";
                resultV2 = "DB100.1860";
                break;
            case 625:
                resultV1 = "1812";
                resultV2 = "1800";
                resultV1 = "DB100.1848";
                resultV2 = "DB100.1824";
                break;
            case 626:
                resultV1 = "1818";
                resultV2 = "1806";
                resultV1 = "DB100.1860";
                resultV2 = "DB100.1836";
                break;
            default:
                return;
@@ -700,7 +892,7 @@
        do {
            try{
                if(!result1.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(resultV1, resultS1);
                    Thread.sleep(100);
                    writeCount++;
@@ -712,14 +904,14 @@
                    if (transInt16 == resultS1){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                        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.toJSON(staProtocol),writeCount);
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result1 = siemensS7Net.Write(resultV1, resultS1);
                    Thread.sleep(100);
                    writeCount++;
@@ -735,7 +927,7 @@
        do {
            try{
                if(!result2.IsSuccess){
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV2, resultS1);
                    Thread.sleep(100);
                    writeCount++;
@@ -747,14 +939,14 @@
                    if (transInt16 == resultS1){
                        break;
                    } else {
                        log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSON(staProtocol),writeCount);
                        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.toJSON(staProtocol),writeCount);
                    log.error("写入RGV数据失败，重新下发任务  写入直接失败 ===>> [id:{}],{},[写入次数:{}]", slave.getId(), JSON.toJSONString(staProtocol),writeCount);
                    result2 = siemensS7Net.Write(resultV2, resultS1);
                    Thread.sleep(100);
                    writeCount++;
@@ -768,11 +960,11 @@

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