rev 更新rgv

acs/hd/nladmin-system/src/main/java/org/nl/acs/device_driver/lnsh/lnsh_package_palletizing_manipulator_site/LnshPackagePalletizingManipulatorSiteDeviceDriver.java

@@ -1042,6 +1042,7 @@ public class LnshPackagePalletizingManipulatorSiteDeviceDriver extends AbstractO
             json.put("vehicle_code",barcode);
             json.put("material_code",material);
             json.put("is_full",type);
+            json.put("is_force","1");
             json.put("product_code",product_code);
             json.put("AlongSide",AlongSide);
             json.put("BshortSide",BshortSide);

acs/hd/nladmin-system/src/main/java/org/nl/acs/opc/DeviceOpcProtocolRunable.java

@@ -148,7 +148,7 @@ public class DeviceOpcProtocolRunable implements Runnable, DataCallback, ServerC
                 UnifiedDataAccessor accessor_value = UnifiedDataAccessorFactory.getAccessor(OpcConfig.udw_opc_value_key);
                 boolean time_out = false;
 
-                while (true) {
+                while (DeviceOpcSynchronizeAutoRun.isRun) {
                     long begin = System.currentTimeMillis();
                     if (log.isTraceEnabled()) {
                         log.trace("{} 开始记时{}", tag, DateUtil.now());
@@ -194,10 +194,10 @@ public class DeviceOpcProtocolRunable implements Runnable, DataCallback, ServerC
                             if (true) {
                                 this.logItemChanged(itemId, accessor_value, value, itemDto);
                             }
-//                            if(!ObjectUtil.isEmpty(value)){
-//                            accessor_value.setValue(itemId, value);
-//                            }
-                            accessor_value.setValue(itemId, value);
+                            if(!ObjectUtil.isEmpty(value)){
+                                accessor_value.setValue(itemId, value);
+                            }
+                            //accessor_value.setValue(itemId, value);
                         }
                     }
 
@@ -240,8 +240,8 @@ public class DeviceOpcProtocolRunable implements Runnable, DataCallback, ServerC
 
                 }
 
-//                log.warn("opc线程停止。。。");
-//                return;
+                log.warn("opc线程停止。。。");
+                return;
             } catch (Exception var27) {
                 if (this.server != null) {
                     try {
@@ -251,7 +251,7 @@ public class DeviceOpcProtocolRunable implements Runnable, DataCallback, ServerC
                 }
 
                 this.server = null;
-                if (true) {
+                if (!DeviceOpcSynchronizeAutoRun.isRun) {
                     log.warn("opc线程停止2。。。");
                     return;
                 }

acs/hd/nladmin-system/src/main/java/org/nl/acs/opc/OpcEntity.java

@@ -1,177 +0,0 @@
-package org.nl.acs.opc;
-
-import org.nl.modules.udw.UnifiedDataAccessor;
-import org.nl.modules.udw.UnifiedDataAccessorFactory;
-import org.nl.start.auto.run.DeviceOpcSynchronizeAutoRun;
-import org.nl.utils.SpringContextHolder;
-import org.openscada.opc.lib.da.Group;
-import org.openscada.opc.lib.da.Item;
-import org.openscada.opc.lib.da.ItemState;
-
-import java.util.*;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.stream.Collectors;
-
-public class OpcEntity {
-
-    OpcServerService opcServerService = SpringContextHolder.getBean(OpcServerService.class);
-    private final UnifiedDataAccessor udw;
-    private Map<String, List<Item>> items;
-    private Map<String, List<String>> someFailDevices;
-    private String opcCode;
-
-    public OpcEntity(String opcCode) {
-        this.udw = UnifiedDataAccessorFactory.getAccessor(OpcConfig.udw_opc_value_key);
-        this.items = new ConcurrentHashMap();
-        this.someFailDevices = new ConcurrentHashMap();
-        this.opcCode = opcCode;
-    }
-
-    public void reload(List<List<OpcItemDto>> opcItemDtos) {
-        Map<String, List<String>> itemCodes = new ConcurrentHashMap();
-        (opcItemDtos.stream().flatMap(Collection::stream).collect(Collectors.groupingBy(OpcItemDto::getDevice_code))).forEach((deviceCodes, opcItemDtoList) -> {
-            itemCodes.put(deviceCodes, opcItemDtoList.stream().map(OpcItemDto::getItem_code).collect(Collectors.toList()));
-        });
-        DeviceOpcSynchronizeAutoRun.itemCodeOpcItemDtoMapping.putAll((Map)opcItemDtos.stream().flatMap(Collection::stream).collect(Collectors.toMap(OpcItemDto::getItem_code, (obj) -> {
-            return obj;
-        },(k, v) -> k)));
-        if (this.items.size() == 0) {
-            itemCodes.values().stream().flatMap(Collection::stream).forEach((key) -> {
-                this.udw.setValue(key, (Object)null);
-            });
-            this.addItemsIntoGroup(itemCodes);
-        } else {
-            if (this.someFailDevices.size() > 0) {
-                this.reAddDevices();
-            }
-
-        }
-    }
-
-    private void reAddDevices() {
-        Map<String, List<Item>> addItems = new ConcurrentHashMap();
-        StringBuilder err_message = new StringBuilder();
-        this.someFailDevices.forEach((deviceCode, itemCodesList) -> {
-            itemCodesList.forEach((itemCode) -> {
-                try {
-                    Group group =  DeviceOpcSynchronizeAutoRun.getGroup(this.opcCode);
-                    ((List)addItems.computeIfAbsent(deviceCode, (key) -> {
-                        return new ArrayList();
-                    })).add(group.addItem(itemCode));
-                } catch (Exception var6) {
-                    err_message.append(itemCode).append(" 添加失败; ");
-                }
-
-            });
-            List<Item> deviceItems = (List)addItems.get(deviceCode);
-            if (deviceItems != null && deviceItems.size() == itemCodesList.size()) {
-                this.someFailDevices.remove(deviceCode);
-            } else if (itemCodesList.size() == 0) {
-                addItems.remove(deviceCode);
-            } else {
-                assert deviceItems != null;
-
-                ((List)this.someFailDevices.get(deviceCode)).removeAll(deviceItems);
-            }
-
-            synchronized(this.opcCode.intern()) {
-                this.items.putAll(addItems);
-            }
-
-            if (err_message.length() > 0) {
-                String errMsg = err_message.toString();
-                //this.log.warn("{}:{}", com.wxzd.wcs.opc.OpcConfig.resource_code, errMsg);
-            }
-
-        });
-    }
-
-    private void addItemsIntoGroup(Map<String, List<String>> itemCodes) {
-        try {
-            Group group = DeviceOpcSynchronizeAutoRun.getGroup(this.opcCode);
-            StringBuilder err_message = new StringBuilder();
-            Map<String, List<Item>> items = new ConcurrentHashMap();
-            itemCodes.forEach((deviceCode, itemCodesList) -> {
-                itemCodesList.forEach((itemCode) -> {
-                    try {
-                        ((List)items.computeIfAbsent(deviceCode, (key) -> {
-                            return new ArrayList();
-                        })).add(group.addItem(itemCode));
-                    } catch (Exception var7) {
-                        ((List)this.someFailDevices.computeIfAbsent(deviceCode, (key) -> {
-                            return new ArrayList();
-                        })).add(itemCode);
-                        this.udw.setValue(itemCode, (Object)null);
-                        err_message.append(itemCode).append(" 添加失败; ");
-                    }
-
-                });
-                List<Item> deviceItems = (List)items.get(deviceCode);
-                if (deviceItems != null && deviceItems.size() != itemCodesList.size()) {
-                    items.remove(deviceCode);
-                    this.someFailDevices.put(deviceCode, itemCodesList);
-                }
-
-            });
-            synchronized(this.opcCode.intern()) {
-                this.items = items;
-            }
-
-            if (err_message.length() > 0) {
-                String errMsg = err_message.toString();
-//                this.log.warn("{}:{}", OpcConfig.resource_code, errMsg);
-            }
-        } catch (Exception var8) {
-            var8.printStackTrace();
-        }
-
-    }
-
-    public void cleanUdwCache() {
-        this.items.values().stream().flatMap(Collection::stream).map(Item::getId).forEach((key) -> {
-            this.udw.setValue(key, (Object)null);
-        });
-    }
-
-    public Map<Item, ItemState> readAll() throws Exception {
-        return opcServerService.getServer(this.opcCode).read(true, (Item[])this.items.values().stream().flatMap(Collection::stream).toArray((x$0) -> {
-            return new Item[x$0];
-        }));
-    }
-
-    public Map<Item, ItemState> readDividually() {
-        Map<Item, ItemState> result = new HashMap();
-        CompletableFuture[] futures = (CompletableFuture[])this.items.entrySet().stream().map((entry) -> {
-            return CompletableFuture.runAsync(() -> {
-                try {
-                    Group group = DeviceOpcSynchronizeAutoRun.getGroup(this.opcCode);
-                    result.putAll(group.read(true, (Item[])((List)entry.getValue()).toArray(new Item[0])));
-                } catch (Exception var5) {
-                    String deviceCode = (String)entry.getKey();
-                    // to do
-//                    this.someFailDevices.put(deviceCode, ((List)entry.getValue()).stream().map(Item::getId).collect(Collectors.toList()));
-                    this.items.remove(deviceCode);
-                }
-
-            }, DeviceOpcSynchronizeAutoRun.executorService);
-        }).toArray((x$0) -> {
-            return new CompletableFuture[x$0];
-        });
-        CompletableFuture.allOf(futures).join();
-        return result;
-    }
-
-
-    public UnifiedDataAccessor getUdw() {
-        return this.udw;
-    }
-
-    public Map<String, List<Item>> getItems() {
-        return this.items;
-    }
-
-    public String getOpcCode() {
-        return this.opcCode;
-    }
-}

acs/hd/nladmin-system/src/main/java/org/nl/start/auto/run/DeviceOpcSynchronizeAutoRun.java

@@ -1,280 +1,86 @@
 package org.nl.start.auto.run;
 
-import org.apache.lucene.util.NamedThreadFactory;
-import lombok.extern.slf4j.Slf4j;
-
+import cn.hutool.core.util.ObjectUtil;
 import org.nl.acs.opc.*;
-import org.nl.modules.udw.UnifiedDataAccessor;
-import org.nl.modules.udw.UnifiedDataAccessorFactory;
-import org.nl.modules.udw.UnifiedDataAppService;
-import org.nl.utils.SpringContextHolder;
-import org.openscada.opc.lib.da.Group;
-import org.openscada.opc.lib.da.Item;
-import org.openscada.opc.lib.da.ItemState;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
-import java.util.*;
-import java.util.Map.Entry;
-import java.util.concurrent.*;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 /**
  * OPC设备同步启动
  */
 @Component
-@Slf4j
 public class DeviceOpcSynchronizeAutoRun extends AbstractAutoRunnable {
-    static boolean isRun = true;
+
+    public static boolean isRun = false;
+    ExecutorService executorService;
     @Autowired
     private DeviceAppService deviceAppService;
     @Autowired
     private OpcServerManageService opcServerManageService;
-    @Autowired
-//    LuceneExecuteLogService lucene;
-
-    public static ExecutorService executorService;
-    public static Map<String, OpcServerManageDto> opcServersConfig;
-    public static Map<String, OpcItemDto> itemCodeOpcItemDtoMapping = new ConcurrentHashMap();
-
-    static boolean canRefreshOpcEntity = true;
-    private long lastRefreshOpcEntityTime;
-    static UnifiedDataAccessor udw;
-    private static Map<String, Boolean> canReadOpcValues;
-    private static volatile Map<String, OpcEntity> opcCodeOpcEntityMapping;
-
-    public DeviceOpcSynchronizeAutoRun() {
-        this.lastRefreshOpcEntityTime = 0L;
-    }
 
+    @Override
     public String getCode() {
         return DeviceOpcSynchronizeAutoRun.class.getSimpleName();
     }
 
+    @Override
     public String getName() {
         return "opc设备同步器";
     }
 
-    public static Group getGroup(String opcCode) throws Exception {
-        OpcServerService opcServerService = SpringContextHolder.getBean(OpcServerService.class);
-        return opcServerService.getServer(opcCode);
-    }
-
-    static void submitTimeLimitTask(Runnable runnable, String opcCode) {
-        CompletableFuture<Void> future = CompletableFuture.runAsync(runnable, executorService);
-
-//        try {
-//            future.get(10L, TimeUnit.SECONDS);
-//        } catch (InterruptedException var9) {
-//            Thread.currentThread().interrupt();
-//        } catch (ExecutionException var10) {
-//            var10.printStackTrace();
-//        } catch (TimeoutException var11) {
-//            itemCodeOpcItemDtoMapping.keySet().forEach((key) -> {
-//                udw.setValue(key, (Object) null);
-//            });
-//            canReadOpcValues = new ConcurrentHashMap<>();
-//            System.out.println("opc设备同步器 任务执行超时，取消任务...");
-//            future.cancel(true);
-//        } finally {
-//            canRefreshOpcEntity = true;
-//            if (opcCode != null) {
-//                canReadOpcValues.put(opcCode, true);
-//            }
-//
-//        }
-    }
-
-    private ExecutorService createThreadPool() {
-        ThreadPoolExecutor executor = new ThreadPoolExecutor(32, 32, 10L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new NamedThreadFactory("opc-sync"));
-        executor.allowCoreThreadTimeOut(true);
-        return executor;
-    }
-
-    public void autoRun() {
-        OpcStartTag.is_run = true;
-        opcServersConfig = this.opcServerManageService.queryAllServerMap();
-        executorService = this.createThreadPool();
-        opcCodeOpcEntityMapping = new ConcurrentHashMap();
-        itemCodeOpcItemDtoMapping.keySet().forEach((key) -> {
-            udw.setValue(key, (Object) null);
-        });
-        canRefreshOpcEntity = true;
-        canReadOpcValues.clear();
-
-        while (true) {
-            this.refreshOpcEntity();
-            Iterator var1 = opcServersConfig.keySet().iterator();
-
-            while (var1.hasNext()) {
-                String opcCode = (String) var1.next();
-                submitTimeLimitTask(() -> {
-                    boolean in = false;
-                    try {
-                        if (canReadOpcValues.computeIfAbsent(opcCode, (key) -> true)) {
-                            in = true;
-                            canReadOpcValues.put(opcCode, false);
-                            this.readOpcValues(opcCode);
-                        }
-                    } catch (Exception var3) {
-                        var3.printStackTrace();
-                    } finally {
-                        canRefreshOpcEntity = true;
-                        if (opcCode != null && in) {
-                            canReadOpcValues.put(opcCode, true);
-                        }
-                    }
-                }, opcCode);
+    @Override
+    public void autoRun() throws Exception {
+        {
+            isRun = true;
+            this.executorService = Executors.newCachedThreadPool();
+            Map<String, OpcServerManageDto> servers = this.opcServerManageService.queryAllServerMap();
+            Map<String, List<List<OpcItemDto>>> pros;
+            do{
+                Thread.sleep(1000L);
+                pros = this.deviceAppService.findAllFormatProtocolFromDriver();
+            }while (ObjectUtil.isEmpty(pros));
+            Set<String> keys = pros.keySet();
+            Iterator var4 = keys.iterator();
+            //代码执行一次
+            while (var4.hasNext()) {
+                String key = (String) var4.next();
+                List<List<OpcItemDto>> list = (List) pros.get(key);
+                OpcServerManageDto opcServer = (OpcServerManageDto) servers.get(key);
+                Iterator var8 = list.iterator();
+                while (var8.hasNext()) {
+                    List<OpcItemDto> groupProtols = (List) var8.next();
+                    DeviceOpcProtocolRunable runable = new DeviceOpcProtocolRunable();
+                    runable.setProtocols(groupProtols);
+                    runable.setOpcServer(opcServer);
+                    this.executorService.submit(runable);
+                }
             }
 
-            ThreadUtl.sleep((long) OpcConfig.synchronized_millisecond);
-        }
-    }
-
-    private void readOpcValues(String opcCode) throws Exception {
-        synchronized (opcCode.intern()) {
-            OpcEntity opcEntity = (OpcEntity) opcCodeOpcEntityMapping.get(opcCode);
-            if (opcEntity != null) {
-                if (opcEntity.getItems().size() != 0) {
-                    long begin = System.currentTimeMillis();
-                    if (log.isTraceEnabled()) {
-                        log.trace("opc {} 开始计时{}", opcCode, begin);
-                    }
-
-                    new HashMap();
-
-                    Map<Item, ItemState> itemStatus;
-                    try {
-                        itemStatus = opcEntity.readAll();
-                    } catch (Exception var15) {
-                        itemStatus = opcEntity.readDividually();
-                    }
-
-                    long end = System.currentTimeMillis();
-                    long duration = end - begin;
-                    if (log.isTraceEnabled()) {
-                        log.trace("opc {} 读取耗时：{}", opcCode, duration);
-                    }
-
-                    if (duration > 1000L) {
-                        log.warn("opc {} 读取超时 : {}", opcCode, duration);
-                    }
-
-//                    boolean allNull = itemStatus.entrySet().stream().map((map) -> {
-//                        return OpcUtl.getValue((Item)map.getKey(), (ItemState)map.getValue());
-//                    }).allMatch(Objects::isNull);
-//                    if (allNull) {
-//                        opcEntity.getItems().clear();
-//                    }
-
-                    UnifiedDataAccessor udw = opcEntity.getUdw();
-
-
-                    Set<Item> items = itemStatus.keySet();
-                    Iterator var18 = items.iterator();
-
-                    while (var18.hasNext()) {
-                        Item item = (Item) var18.next();
-                        ItemState itemState = (ItemState) itemStatus.get(item);
-                        Object nowValue = OpcUtl.getValue(item, itemState);
-                        String itemId = item.getId();
-                        Object historyValue = udw.getValue(itemId);
-                        if (!ObjectUtl.isEquals(itemState.getQuality(), QualityTypeValue.OPC_QUALITY_GOOD) && historyValue != null) {
-                            log.warn("opc 值不健康 item: {}, 状态: {}", itemId, itemState.getQuality());
-                        }
-                        if (!UnifiedDataAppService.isEquals(nowValue, historyValue)) {
-                            OpcItemDto itemDto = (OpcItemDto) itemCodeOpcItemDtoMapping.get(itemId);
-                            if (true) {
-                                this.logItemChanged(itemId, udw, nowValue, itemDto);
-                            }
-                            udw.setValue(itemId, nowValue);
-                        }
-
-                    }
+            // 同步无光电设备信号
+            //Map<String, List<List<OpcItemDto>>> pros1 = this.deviceAppService.findAllFormatProtocolFromDriver();
+            //List<DeviceDriver> opcDrivers = this.deviceAppService.findDeviceDriver(DeviceDriver.class);
 
+            while(true) {
+                try {
+                    Thread.sleep(3600000L);
+                } catch (InterruptedException var11) {
+                    return;
                 }
             }
         }
     }
 
-    private void refreshOpcEntity() {
-        if (canRefreshOpcEntity) {
-            canRefreshOpcEntity = false;
-            long now = System.currentTimeMillis();
-            if (now - this.lastRefreshOpcEntityTime >= 20000L) {
-                this.lastRefreshOpcEntityTime = now;
-                submitTimeLimitTask(() -> {
-                    try {
-                        Map<String, List<List<OpcItemDto>>> protocol = this.deviceAppService.findAllFormatProtocolFromDriver();
-                        Iterator var2 = protocol.entrySet().iterator();
-
-                        while (var2.hasNext()) {
-                            Entry<String, List<List<OpcItemDto>>> stringListEntry = (Entry) var2.next();
-                            String opcCode = (String) stringListEntry.getKey();
-                            List<List<OpcItemDto>> opcItemDtos = (List) stringListEntry.getValue();
-                            ((OpcEntity) opcCodeOpcEntityMapping.computeIfAbsent(opcCode, OpcEntity::new)).reload(opcItemDtos);
-                        }
-                    } catch (Exception var6) {
-                        var6.printStackTrace();
-                    } finally {
-                        canRefreshOpcEntity = true;
-                    }
-
-                }, (String) null);
-            }
-        }
-    }
-
-    private void logMessage(String errorMessage) {
-        try {
-//            issueLogger.setResource(OpcConfig.resource_code, OpcConfig.resource_name).setError(StringUtl.getString(100), "设备同步通信异常").log(errorMessage, new Object[0]);
-//            businessLogger.setResource(OpcConfig.resource_code, OpcConfig.resource_name).setError(StringUtl.getString(100), "设备同步通信异常").log(errorMessage, new Object[0]);
-        } catch (Exception var5) {
-            var5.printStackTrace();
-        }
-
-    }
-
+    @Override
     public void after() {
-        OpcStartTag.is_run = false;
-        opcCodeOpcEntityMapping.values().forEach((opcEntity) -> {
-            opcEntity.cleanUdwCache();
-            OpcServerService opcServerService = SpringContextHolder.getBean(OpcServerService.class);
-            opcServerService.cleanGroups(opcEntity.getOpcCode());
-        });
-        opcCodeOpcEntityMapping = new ConcurrentHashMap();
-        itemCodeOpcItemDtoMapping = new ConcurrentHashMap();
-        executorService.shutdownNow();
-    }
-
-    private void logItemChanged(String itemCode, UnifiedDataAccessor udw, Object value, OpcItemDto itemDto) {
-        Object his = udw.getValue(itemCode);
-        List<String> relate_items = itemDto.getRelate_items();
-        if (relate_items != null && !relate_items.isEmpty()) {
-            StringBuilder sb = new StringBuilder();
-            Iterator var8 = relate_items.iterator();
-
-            while (var8.hasNext()) {
-                String relate = (String) var8.next();
-                Object obj = udw.getValue(relate);
-                sb.append("key:").append(relate).append("value:").append(obj).append(";");
-            }
-            if (!itemCode.endsWith("heartbeat") && !itemCode.endsWith("time")) {
-                log.warn("{} 信号 {} 发生变更 {} -> {} 信号快照 {}", itemDto.getDevice_code(), itemCode, his, value, sb);
-                //lucene.deviceExecuteLog(new LuceneLogDto(itemDto.getOpc_server_code(), itemDto.getOpc_plc_code(), itemDto.getDevice_code(), itemDto.getItem_code().substring(itemDto.getItem_code().lastIndexOf(".") + 1), String.valueOf(his), String.valueOf(value)));
-            }
-
-        } else {
-            if (!itemCode.endsWith("heartbeat") && !itemCode.endsWith("time")) {
-                log.warn("{} 信号 {} 发生变更 {} -> {}", itemDto.getDevice_code(), itemCode, his, value);
-//                lucene.deviceExecuteLog(new LuceneLogDto(itemDto.getOpc_server_code(), itemDto.getOpc_plc_code(), itemDto.getDevice_code(), itemDto.getItem_code().substring(itemDto.getItem_code().lastIndexOf(".") + 1), String.valueOf(his), String.valueOf(value)));
-            }
-        }
-    }
-
-
-    static {
-        udw = UnifiedDataAccessorFactory.getAccessor(OpcConfig.udw_opc_value_key);
-        canReadOpcValues = new ConcurrentHashMap();
-        opcCodeOpcEntityMapping = new ConcurrentHashMap();
+        isRun = false;
+        this.executorService.shutdownNow();
+        this.executorService = Executors.newCachedThreadPool();
     }
 }

acs/hd/nladmin-system/src/main/java/org/nl/start/auto/run/NDCSocketConnectionAutoRun.java

@@ -2,6 +2,8 @@ package org.nl.start.auto.run;
 
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
+import cn.hutool.http.HttpResponse;
+import com.alibaba.fastjson.JSONObject;
 import lombok.extern.slf4j.Slf4j;
 import org.nl.acs.agv.server.NDCAgvService;
 import org.nl.acs.agv.server.dto.AgvDto;
@@ -445,13 +447,10 @@ public class NDCSocketConnectionAutoRun extends AbstractAutoRunnable {
                                             inst.setExecute_status("9");
                                             instructionService.update(inst);
                                             try {
-                                                while (!StrUtil.equals(String.valueOf(lnshLaminatingMachineDeviceDriver.getTo_task()), inst.getInstruction_code())
-                                                        || !StrUtil.equals(String.valueOf(lnshLaminatingMachineDeviceDriver.getTo_command()), "1")) {
-
-                                                    lnshLaminatingMachineDeviceDriver.writing("to_task", inst.getInstruction_code());
-                                                    lnshLaminatingMachineDeviceDriver.writing(1);
-                                                    ThreadUtl.sleep(500);
-                                                }
+                                                lnshLaminatingMachineDeviceDriver.writing("to_task", inst.getInstruction_code());
+                                                lnshLaminatingMachineDeviceDriver.writing("to_task", inst.getInstruction_code());
+                                                lnshLaminatingMachineDeviceDriver.writing(1);
+                                                lnshLaminatingMachineDeviceDriver.writing(1);
                                             } catch (Exception e) {
                                                 log.info("下发电气信号失败:" + e.getMessage());
                                                 e.printStackTrace();
@@ -460,14 +459,27 @@ public class NDCSocketConnectionAutoRun extends AbstractAutoRunnable {
                                         }
                                         //如果组盘绑定条码成功，就允许agv离开
                                         if (lnshLaminatingMachineDeviceDriver.getMode() == 6) {
-                                            boolean intoKiln = lnshLaminatingMachineDeviceDriver.intoKiln();
-                                            if (intoKiln) {
-                                                while (6 != lnshLaminatingMachineDeviceDriver.getTo_command()) {
-                                                    lnshLaminatingMachineDeviceDriver.writing(6);
-                                                    ThreadUtl.sleep(500);
+                                            JSONObject json = new JSONObject();
+                                            json.put("device_code",lnshLaminatingMachineDeviceDriver.getDevice_code());
+                                            json.put("vehicle_code",lnshLaminatingMachineDeviceDriver.autoGenericCode(String.valueOf(lnshLaminatingMachineDeviceDriver.getBarcode())));
+                                            json.put("task_code",inst.getTask_code());
+                                            logServer.deviceExecuteLog(lnshLaminatingMachineDeviceDriver.getDevice_code(), "", "", "申请组盘请求lms:"+json);
+                                            HttpResponse result = acsToWmsService.applyIntoKiln(json);
+                                            if (ObjectUtil.isNotEmpty(result)) {
+                                                JSONObject jsonObject = JSONObject.parseObject(result.body());
+                                                if (result.getStatus() == 200 && StrUtil.equals(jsonObject.get("status").toString(),"200")) {
+                                                    try{
+                                                        lnshLaminatingMachineDeviceDriver.writing(6);
+                                                        lnshLaminatingMachineDeviceDriver.writing(6);
+                                                    } catch (Exception e) {
+                                                        e.printStackTrace();
+                                                    }
+
+                                                    data = AgvService.sendAgvOneModeInst(phase, index, 0);
+                                                }else {
+                                                    logServer.deviceExecuteLog(lnshLaminatingMachineDeviceDriver.getDevice_code(), "", "", "申请组盘请求lms反馈失败:"+result);
                                                 }
-                                                data = AgvService.sendAgvOneModeInst(phase, index, 0);
-                                                flag = true;
+                                                logServer.deviceExecuteLog(lnshLaminatingMachineDeviceDriver.getDevice_code(), "", "", "申请组盘请求lms反馈:"+result);
                                             }
                                         }
                                     }