Merge remote-tracking branch 'origin/master' into master

imcs-admin-boot/imcs-business-biz/src/main/java/com/github/zuihou/business/mq/TaskWorkNode.java

@@ -263,7 +263,7 @@ public class TaskWorkNode {
             autoProgrameUrl = UrlConfConstant.url;
         }
         //正式调试的时候注释掉
-        autoProgrameUrl = UrlConfConstant.url;
+//        autoProgrameUrl = UrlConfConstant.url;
         return autoProgrameUrl;
     }
 

imcs-admin-boot/imcs-business-biz/src/main/java/com/github/zuihou/business/operationManagementCenter/service/WorkpieceService.java

@@ -80,4 +80,6 @@ public interface WorkpieceService extends SuperService<TWorkpiece> {
     R productLineRunMode()  throws Exception;
 
     R measuringProgramName() throws Exception;
+
+    R executeOrder(Map paraMap) ;
 }

imcs-admin-boot/imcs-business-biz/src/main/java/com/github/zuihou/business/operationManagementCenter/service/impl/OrderServiceImpl.java

@@ -368,7 +368,7 @@ public class OrderServiceImpl extends SuperServiceImpl<OrderMapper, Order> imple
                         for (int partNum = 0; partNum < planProduct.getPlanBomNum(); partNum++) {
                             TWorkpiece workpiece = new TWorkpiece();
                             workpiece.setBomId(planProduct.getBomId()).setCompleteBatchNo(UUID.randomUUID().toString().replace("-", "")).setOrderId(planProduct.getOrderId()).setOrderNo(planProduct.getOrderNo())
-                                    .setPlanId(planProduct.getPlanId()).setPlanNo(planProduct.getPlanNo()).setBomName(bbomsMap.get(planProduct.getBomId()).getName());
+                                    .setPlanId(planProduct.getPlanId()).setPlanNo(planProduct.getPlanNo()).setBomName(bbomsMap.get(planProduct.getBomId()).getName()).setBomNo(bbomsMap.get(planProduct.getBomId()).getNo()).setOrderName(oriBean.getOrderName());
                             workpieceMapper.insert(workpiece);
 
                             // 生成task表，因为工序定了以后不变，排产时只需更新预计开始时间和结束时间

imcs-admin-boot/imcs-business-biz/src/main/java/com/github/zuihou/business/operationManagementCenter/service/impl/TaskNodeServiceImpl.java

@@ -333,7 +333,7 @@ public class TaskNodeServiceImpl extends SuperServiceImpl<TaskNodeMapper, TaskNo
                         taskNode.setTaskId(t.getId()).setOrderId(t.getOrderId())
                                 .setTaskNodeNo(codeRuleService.getBillCode(CodeRuleModule.CODE_RULE_TASK_NODE));
                         taskNode.setAutoNode(autoCode).setNodeNo(autoCode.getNo()).setCompleteBatchNo(t.getCompleteBatchNo())
-                                .setExeStatus("1").setPrority(autoCode.getWeight());
+                                .setExeStatus("1").setPrority(autoCode.getWeight()).setNodeName(autoCode.getName());
 //                    if (autoNode.getInterfaceType() != null) {
 //                        taskNode.setInterfaceType(autoNode.getInterfaceType().getKey());
 //                    }
@@ -1621,36 +1621,67 @@ public class TaskNodeServiceImpl extends SuperServiceImpl<TaskNodeMapper, TaskNo
         }
         String taskInfos = msgUtil.redis_get(manualId).toString();
         JSONObject taskInfosObject = JSONObject.parseObject(taskInfos);
-        List<String> taskNodes = JSONArray.parseArray(taskInfosObject.getString("taskNodes"),String.class);
+        List<String> remindRobotNodes = JSONArray.parseArray(taskInfosObject.getString("remindRobotNodes"),String.class);
         ManualInfo manualInfo = JSONObject.parseObject(taskInfosObject.getString("taskInfo"),ManualInfo.class);
         // 动作指令,完成直接返回成功
         if(manualInfo.getNextTaskNodeIndex() == -1){
             return R.success();
         }else{
-            if(manualInfo.getNextTaskNodeIndex() > taskNodes.size() -1){
+            if(manualInfo.getNextTaskNodeIndex() > remindRobotNodes.size() -1){
                 Map queryMap = new HashMap();
                 queryMap.put("pointId", manualInfo.getStartpointId());
                 queryMap.put("resourceId", manualInfo.getStartResourceId());
-
                 List<ProductionresourcePosition> sourceList = productionresourcePositionMapper.getStorgeIdByResource(queryMap);
-
                 queryMap.clear();
                 queryMap.put("pointId", manualInfo.getEndpointId());
                 queryMap.put("resourceId", manualInfo.getEndResourceId());
                 List<ProductionresourcePosition> targetList = productionresourcePositionMapper.getStorgeIdByResource(queryMap);
 
-                // 先将原库位上所有物料信息读取出来
-                List<StockInfo> stockInfos = stockInfoMapper.selectList(Wraps.<StockInfo>lbQ().eq(StockInfo::getStorgeId, sourceList.get(0).getStorgeId()));
-                for(StockInfo stockInfo : stockInfos){
-                    // 更新出库信息
-                    saveStockLog(stockInfo,BizConstant.STOCK_TYPE_OUT);
-                    // 更新入库信息
-                    stockInfo.setStorgeId(targetList.get(0).getStorgeId());
-                    saveStockLog(stockInfo,BizConstant.STOCK_TYPE_IN);
-                    // 更新库位物料信息
-                    stockInfoMapper.updateById(stockInfo);
+                // 判断是否是设备节点，还有后续指令节点
+                if(StringUtils.isNotBlank(manualInfo.getTaskId())){
+                    // 先将原库位上所有物料信息读取出来
+                    List<StockInfo> stockInfos = stockInfoMapper.selectList(Wraps.<StockInfo>lbQ().eq(StockInfo::getStorgeId, sourceList.get(0).getStorgeId()));
+                    for(StockInfo stockInfo : stockInfos){
+                        // 更新出库信息
+                        saveStockLog(stockInfo,BizConstant.STOCK_TYPE_OUT);
+                        // 更新入库信息
+                        stockInfo.setStorgeId(targetList.get(0).getStorgeId());
+                        saveStockLog(stockInfo,BizConstant.STOCK_TYPE_IN);
+                        // 更新库位物料信息
+                        stockInfoMapper.updateById(stockInfo);
+                    }
+                    msgUtil.redis_del(manualInfo.getManualId());
+                }else{
+                    TaskNode currentTaskNode = manualInfo.getTaskNode();
+                    // 更新当前节点完成状态
+                    currentTaskNode.setExeStatus("3");
+                    currentTaskNode.setExeResult("1");
+                    baseMapper.updateById(currentTaskNode);
+                    TaskNode nextTaskNode =  this.getNextNTaskNode(currentTaskNode,1);
+                    // 没有后续指令
+                    if(null == nextTaskNode){
+                        // 先将原库位上所有物料信息读取出来
+                        List<StockInfo> stockInfos = stockInfoMapper.selectList(Wraps.<StockInfo>lbQ().eq(StockInfo::getStorgeId, sourceList.get(0).getStorgeId()));
+                        for(StockInfo stockInfo : stockInfos){
+                            // 更新出库信息
+                            saveStockLog(stockInfo,BizConstant.STOCK_TYPE_OUT);
+                            // 更新入库信息
+                            stockInfo.setStorgeId(targetList.get(0).getStorgeId());
+                            saveStockLog(stockInfo,BizConstant.STOCK_TYPE_IN);
+                            // 更新库位物料信息
+                            stockInfoMapper.updateById(stockInfo);
+                        }
+                        msgUtil.redis_del(manualInfo.getManualId());
+                    }else{
+                        // 设备还有后续指令需要执行
+                        // AGV 调度
+                        if(null == nextTaskNode.getResourceId()){
+
+                        }else{
+                            // 设备任务
+                        }
+                    }
                 }
-                msgUtil.redis_del(manualInfo.getManualId());
 
                 // 通知手动页面刷新库位信息
                 // 组装参数
@@ -1697,7 +1728,7 @@ public class TaskNodeServiceImpl extends SuperServiceImpl<TaskNodeMapper, TaskNo
                 map.put("resourceId", manualInfo.getRobotResourceId());
                 List<ProductionresourcePosition> productionresourcePositions = productionresourcePositionMapper.getProductlineStockInfo(map);
 
-                Map<String,Object> processInfo =  ManualTaskOperatorUtil.judgeProcessInfo((ArrayList<String>) taskNodes,manualInfo, productionresourcePositions);
+                Map<String,Object> processInfo =  ManualTaskOperatorUtil.judgeProcessInfo((ArrayList<String>) remindRobotNodes,manualInfo, productionresourcePositions);
                 JSONObject returnDataObject = new JSONObject();
 
                 // 组装参数

imcs-admin-boot/imcs-business-biz/src/main/java/com/github/zuihou/business/operationManagementCenter/service/impl/WorkpieceServiceImpl.java

@@ -7,37 +7,44 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.github.zuihou.base.R;
 import com.github.zuihou.base.service.SuperServiceImpl;
+import com.github.zuihou.business.edgeLibrary.dao.StockInfoMapper;
 import com.github.zuihou.business.edgeLibrary.dao.StorgeMapper;
+import com.github.zuihou.business.edgeLibrary.entity.StockInfo;
 import com.github.zuihou.business.edgeLibrary.entity.Storge;
 import com.github.zuihou.business.externalApi.dto.ManualInfo;
 import com.github.zuihou.business.mq.HandModeWorkNode;
+import com.github.zuihou.business.operationManagementCenter.dao.TTaskMapper;
 import com.github.zuihou.business.operationManagementCenter.dao.WorkpieceMapper;
+import com.github.zuihou.business.operationManagementCenter.entity.TTask;
 import com.github.zuihou.business.operationManagementCenter.entity.TWorkpiece;
 import com.github.zuihou.business.operationManagementCenter.entity.TaskNode;
 import com.github.zuihou.business.operationManagementCenter.service.TaskNodeService;
 import com.github.zuihou.business.operationManagementCenter.service.WorkpieceService;
 import com.github.zuihou.business.productionReadyCenter.dao.BBomMapper;
 import com.github.zuihou.business.productionReadyCenter.dao.BomProcedureMapper;
-import com.github.zuihou.business.productionReadyCenter.entity.MToolClamp;
-import com.github.zuihou.business.productionReadyCenter.entity.Tray;
+import com.github.zuihou.business.productionReadyCenter.dao.BomProcedureTrayMapper;
+import com.github.zuihou.business.productionReadyCenter.entity.*;
 import com.github.zuihou.business.productionReadyCenter.service.MToolClampService;
 import com.github.zuihou.business.productionReadyCenter.service.TrayService;
 import com.github.zuihou.business.productionResourceCenter.dao.ProductionresourceBizMapper;
 import com.github.zuihou.business.productionResourceCenter.dao.ProductionresourcePositionMapper;
 import com.github.zuihou.business.productionResourceCenter.dao.ZZoneMapper;
 import com.github.zuihou.business.productionResourceCenter.dao.ZZoneProductionresourceMapper;
+import com.github.zuihou.business.productionResourceCenter.entity.Productionresource;
 import com.github.zuihou.business.productionResourceCenter.entity.ProductionresourcePosition;
 import com.github.zuihou.business.productionResourceCenter.entity.ZZone;
 import com.github.zuihou.business.productionResourceCenter.entity.ZZoneProductionresource;
 import com.github.zuihou.business.productionResourceCenter.service.ProductionresourcePositionService;
 import com.github.zuihou.business.util.ManualTaskOperatorUtil;
 import com.github.zuihou.business.util.MsgUtil;
+import com.github.zuihou.common.constant.DictionaryKey;
 import com.github.zuihou.common.util.StringUtil;
 import com.github.zuihou.context.BaseContextHandler;
 import com.github.zuihou.database.mybatis.conditions.Wraps;
 import com.github.zuihou.database.mybatis.conditions.query.LbqWrapper;
 import com.github.zuihou.tenant.dao.ProductionresourceMapper;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections.map.HashedMap;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpEntity;
 import org.springframework.http.HttpHeaders;
@@ -89,14 +96,10 @@ public class WorkpieceServiceImpl extends SuperServiceImpl<WorkpieceMapper, TWor
     @Autowired
     private StorgeMapper storgeMapper;
 
-    @Autowired
-    private BBomMapper bomMapper;
     @Autowired
     private ZZoneMapper zZoneMapper;
     @Autowired
     private ZZoneProductionresourceMapper zZoneProductionresourceMapper;
-    @Autowired
-    private ProductionresourceMapper productionresourceMapper;
 
     @Autowired
     private RestTemplate restTemplate;
@@ -104,6 +107,14 @@ public class WorkpieceServiceImpl extends SuperServiceImpl<WorkpieceMapper, TWor
     private MsgUtil msgUtil;
     @Autowired
     private BomProcedureMapper bomProcedureMapper;
+    @Autowired
+    private TTaskMapper tTaskMapper;
+    @Autowired
+    private StockInfoMapper stockInfoMapper;
+    @Autowired
+    private BomProcedureTrayMapper bomProcedureTrayMapper;
+    @Autowired
+    private BBomMapper bBomMapper;
 
     private static ArrayList<String> robotTaskNodes = new ArrayList<>();
     static {
@@ -185,38 +196,36 @@ public class WorkpieceServiceImpl extends SuperServiceImpl<WorkpieceMapper, TWor
     public List getOrderInfo() {
         BaseContextHandler.setTenant("0000");
         List<Map>returnList = new ArrayList<Map>();
-        List<TWorkpiece>list = baseMapper.selectList(Wraps.<TWorkpiece>lbQ().eq(TWorkpiece::getIsEnd,"0"));
+        List<TWorkpiece> list = baseMapper.selectList(Wraps.<TWorkpiece>lbQ().eq(TWorkpiece::getProduceStatus,"1"));
 
+        // 取得工件对应加工设备首个工序任务
+        Map existResource = new HashedMap();
         for(TWorkpiece workpiece:list){
             Map<String,String> map = new<String,String> HashMap();
-            map.put("pointId",StringUtil.isEmpty(workpiece.getPointId())?"":workpiece.getPointId());
-            map.put("orderName",StringUtil.isEmpty(workpiece.getOrderName())?"":workpiece.getOrderName());
-            map.put("bomNo",StringUtil.isEmpty(workpiece.getBomNo())?"":workpiece.getBomNo());
-            map.put("bomName",StringUtil.isEmpty(workpiece.getBomName())?"":workpiece.getBomName());
-            map.put("procedureName",StringUtil.isEmpty(workpiece.getProcedureName())?"":workpiece.getProcedureName());
-//        if(CollectionUtil.isEmpty(list)){
-//            return new HashMap();
-//        }
-
+            // 查找工件第一个任务信息及所在设备
+            TTask task = tTaskMapper.selectOne(Wraps.<TTask>lbQ().eq(TTask::getStatus,"1").orderByAsc(TTask::getProcedureSort).last("limit 1"));
+            if(!existResource.containsKey(task.getResourceId())){
+                existResource.put(task.getResourceId(),task.getResourceId());
+                // 查找设备点位信息，先判断库位信息是否有数据，如果库位信息有数据，直接用库位信息表里面的点位，可能移动到线边库，如果没有直接显示在工序目标设备的点位上
+                StockInfo stockInfo = stockInfoMapper.selectOne(Wraps.<StockInfo>lbQ().eq(StockInfo::getCompleteBatchNo,workpiece.getCompleteBatchNo()).last("limit 1"));
+                long storgeId = stockInfo.getStorgeId();
+                ProductionresourcePosition productionresourcePosition = productionresourcePositionMapper.selectOne(Wraps.<ProductionresourcePosition>lbQ().eq(ProductionresourcePosition::getStorgeId,storgeId).last("limit 1"));
+                map.put("pointId",StringUtil.isEmpty(productionresourcePosition.getPointId())?"":workpiece.getPointId());
+                map.put("taskId",String.valueOf(task.getId()));
+                map.put("orderName",StringUtil.isEmpty(workpiece.getOrderName())?"":workpiece.getOrderName());
+                map.put("bomNo",StringUtil.isEmpty(workpiece.getBomNo())?"":workpiece.getBomNo());
+                map.put("bomName",StringUtil.isEmpty(workpiece.getBomName())?"":workpiece.getBomName());
+                map.put("procedureName",StringUtil.isEmpty(workpiece.getProcedureName())?"":workpiece.getProcedureName());
+            }
 
-//            //根据库位查询
+//            if(workpiece.getTaskNodeId()!=null){
+//                //查询下一个节点任务，待办任务
+//                TaskNode taskNode = taskNodeService.getById(workpiece.getTaskNodeId());
 //
-//            if(workpiece.getStorgeId()!=null){
-//                List<ProductionresourcePosition>positionList = productionresourcePositionService.list(Wraps.<ProductionresourcePosition>lbQ().eq(ProductionresourcePosition::getStorgeId,workpiece.getStorgeId()));
-//                if(CollectionUtil.isNotEmpty(positionList)){
-//                    ProductionresourcePosition pp = positionList.get(0);
-//                    map.put("lockStatus",pp.getStatus());
-//                }
+//                TaskNode nextTaskNode = taskNodeService.getNextNTaskNode(taskNode, 1);
+//                map.put("nodeName",nextTaskNode.getNodeName());
+//                map.put("nodeId",nextTaskNode.getId().toString());
 //            }
-
-            if(workpiece.getTaskNodeId()!=null){
-                //查询下一个节点任务，待办任务
-                TaskNode taskNode = taskNodeService.getById(workpiece.getTaskNodeId());
-
-                TaskNode nextTaskNode = taskNodeService.getNextNTaskNode(taskNode, 1);
-                map.put("nodeName",nextTaskNode.getNodeName());
-                map.put("nodeId",nextTaskNode.getId().toString());
-            }
             returnList.add(map);
         }
 
@@ -545,7 +554,17 @@ public class WorkpieceServiceImpl extends SuperServiceImpl<WorkpieceMapper, TWor
     @Override
     public R executeManualTask(ManualInfo manualInfo) throws Exception {
         BaseContextHandler.setTenant("0000");
-        Map<String,Object> processInfo =  ManualTaskOperatorUtil.judgeFirstProcessInfo(robotTaskNodes, robotNoMoveTaskNodes,manualInfo);
+        String deviceUnit = manualInfo.getDeviceUnit();
+        ArrayList<String> robotNodes = new ArrayList();
+        // Plc地址
+        if("capsule".equals(deviceUnit)){
+            robotNodes = robotTaskNodes;
+        }else if("framework".equals(deviceUnit)){
+            robotNodes = robotTaskNodes;
+        }else if("safeguard".equals(deviceUnit)){
+            robotNodes = robotNoMoveTaskNodes;
+        }
+        Map<String,Object> processInfo =  ManualTaskOperatorUtil.judgeFirstProcessInfo(robotNodes,manualInfo,null);
         JSONObject returnDataObject = new JSONObject();
 
         // 组装参数
@@ -573,8 +592,8 @@ public class WorkpieceServiceImpl extends SuperServiceImpl<WorkpieceMapper, TWor
             if("true".equals(returnDataObject.get("result"))){
                 // 放入redis，方便回调的时候判断是否是最后一个结点，如果是最后一个结点不在做任何逻辑，更新相应的库位信息
                 Map<String, Object> currentTask = new HashMap<String, Object>();
-                List<String> taskNodes = (List<String>) processInfo.get("remindTaskNodes");
-                currentTask.put("taskNodes",taskNodes);
+                List<String> remindRobotNodes = (List<String>) processInfo.get("remindRobotNodes");
+                currentTask.put("taskNodes",remindRobotNodes);
                 currentTask.put("taskInfo",manualInfo);
                 JSONObject redisTask = new JSONObject();
                 redisTask.putAll(currentTask);
@@ -604,5 +623,163 @@ public class WorkpieceServiceImpl extends SuperServiceImpl<WorkpieceMapper, TWor
         return R.success(bomProcedureMapper.selectMeasuringProgramNames());
 
     }
+    @Override
+    public R executeOrder(Map paraMap) {
+        // 根据taskid查找工序任务
+        long taskId = Long.valueOf(paraMap.get("taskId").toString());
+        TTask tTask = tTaskMapper.selectById(taskId);
+        // 工序节点子任务
+        List<TaskNode> taskNodes = taskNodeService.list(Wraps.<TaskNode>lbQ().eq(TaskNode::getCompleteBatchNo,tTask.getCompleteBatchNo()).orderByAsc(TaskNode:: getPrority));
+        // 工件信息
+        TWorkpiece workpiece = baseMapper.selectOne(Wraps.<TWorkpiece>lbQ().eq(TWorkpiece::getCompleteBatchNo,tTask.getCompleteBatchNo()));
+
+        // 查找工件所属产线
+        BBom bom = bBomMapper.selectById(workpiece.getBomId());
+        ZZone zZone = zZoneMapper.selectById(bom.getZoneId());
+        // 根据工序判断需要做什么任务
+        BomProcedure bomProcedure = bomProcedureMapper.selectOne(Wraps.<BomProcedure>lbQ().eq(BomProcedure::getBomId,workpiece.getBomId()).eq(BomProcedure::getId,tTask.getProcedureId()));
+        // 人工序只有上下料
+        if("上料".equals(bomProcedure.getType())){
+            // 判断当前任务所属产品，找出相应的子盘夹具
+            BomProcedureTray bomProcedureTray = bomProcedureTrayMapper.selectOne(Wraps.<BomProcedureTray>lbQ().eq(BomProcedureTray::getProcedureId,tTask.getProcedureId()));
+            // 判断夹具是否有可用的，查询330个库位信息中是否还有夹具
+            List<StockInfo> stockInfos = stockInfoMapper.selectList(Wraps.<StockInfo>lbQ().eq(StockInfo::getGoodsId,bomProcedureTray.getTrayId()).orderByAsc(StockInfo::getStorgeId));
+            if(stockInfos.size() <= 0){
+                return R.fail("托盘数量不足");
+            }
+            // 按照顺序将托盘移动到上下料站
+            // 获取抓取托盘起点及放设备重点
+            StockInfo metetailStockInfo = stockInfos.get(0);
+            ProductionresourcePosition startProductionresourcePosition = productionresourcePositionMapper.selectOne(Wraps.<ProductionresourcePosition>lbQ().eq(ProductionresourcePosition::getStorgeId, metetailStockInfo.getStorgeId()));
+            String startPointid = startProductionresourcePosition.getPointId();
+            ProductionresourcePosition endProductionresourcePosition = productionresourcePositionMapper.selectOne(Wraps.<ProductionresourcePosition>lbQ().eq(ProductionresourcePosition::getResourceId, tTask.getResourceId()));
+            String endPointid = endProductionresourcePosition.getPointId();
+            return processOperation(taskId, tTask, taskNodes, zZone, startPointid, endPointid);
+
+        }else if("下料".equals(bomProcedure.getType())){
+            // 按照顺序将托盘移动到上下料站
+            // 获取抓取托盘起点及放设备重点
+            List<StockInfo> stockInfos = stockInfoMapper.selectList(Wraps.<StockInfo>lbQ().eq(StockInfo::getCompleteBatchNo,tTask.getCompleteBatchNo()));
+            ProductionresourcePosition startProductionresourcePosition = productionresourcePositionMapper.selectOne(Wraps.<ProductionresourcePosition>lbQ().eq(ProductionresourcePosition::getStorgeId, stockInfos.get(0).getStorgeId()));
+            String startPointid = startProductionresourcePosition.getPointId();
+            ProductionresourcePosition endProductionresourcePosition = productionresourcePositionMapper.selectOne(Wraps.<ProductionresourcePosition>lbQ().eq(ProductionresourcePosition::getResourceId, tTask.getResourceId()));
+            String endPointid = endProductionresourcePosition.getPointId();
+            return processOperation(taskId, tTask, taskNodes, zZone, startPointid, endPointid);
+
+        }else if("翻面".equals(bomProcedure.getType())){
+            // 按照顺序将托盘移动到上下料站
+            // 获取抓取托盘起点及放设备重点
+            List<StockInfo> stockInfos = stockInfoMapper.selectList(Wraps.<StockInfo>lbQ().eq(StockInfo::getCompleteBatchNo,tTask.getCompleteBatchNo()));
+            ProductionresourcePosition startProductionresourcePosition = productionresourcePositionMapper.selectOne(Wraps.<ProductionresourcePosition>lbQ().eq(ProductionresourcePosition::getStorgeId, stockInfos.get(0).getStorgeId()));
+            String startPointid = startProductionresourcePosition.getPointId();
+            ProductionresourcePosition endProductionresourcePosition = productionresourcePositionMapper.selectOne(Wraps.<ProductionresourcePosition>lbQ().eq(ProductionresourcePosition::getResourceId, tTask.getResourceId()));
+            String endPointid = endProductionresourcePosition.getPointId();
+            return processOperation(taskId, tTask, taskNodes, zZone, startPointid, endPointid);
+
+        }else{
+            // 按照顺序将托盘移动到上下料站
+            // 根据动作节点拆分
+            List<StockInfo> stockInfos = stockInfoMapper.selectList(Wraps.<StockInfo>lbQ().eq(StockInfo::getCompleteBatchNo,tTask.getCompleteBatchNo()));
+            ProductionresourcePosition startProductionresourcePosition = productionresourcePositionMapper.selectOne(Wraps.<ProductionresourcePosition>lbQ().eq(ProductionresourcePosition::getStorgeId, stockInfos.get(0).getStorgeId()));
+            String startPointid = startProductionresourcePosition.getPointId();
+
+            TaskNode lastActionTaskNode = getNextActionTaskNode(taskNodes,0);
+
+            if(null == lastActionTaskNode.getResourceId()){
+
+            }
+
+            ProductionresourcePosition endProductionresourcePosition = productionresourcePositionMapper.selectOne(Wraps.<ProductionresourcePosition>lbQ().eq(ProductionresourcePosition::getResourceId, lastActionTaskNode.getResourceId()));
+            String endPointid = endProductionresourcePosition.getPointId();
+
+            return processOperation(taskId, tTask, taskNodes, zZone, startPointid, endPointid);
+            // 回调中分段处理
+        }
+    }
+
+    /**
+     *
+     * 遍历查找下一个动作节点的设备，处理特殊的AGV
+     * @return
+     */
+    private TaskNode getNextActionTaskNode(List<TaskNode> taskNodes,int i){
+        TaskNode currTaskNode = taskNodes.get(i);
+        TaskNode nextTaskNode = taskNodeService.getNextNTaskNode(currTaskNode,1);
+        if(i >= taskNodes.size() -1 ){
+            return currTaskNode;
+        }else{
+            if(nextTaskNode.getPrority() > currTaskNode.getPrority()){
+                i++;
+                getNextActionTaskNode(taskNodes,i);
+            }else{
+                return currTaskNode;
+            }
+        }
+        return null;
+    }
+
+    private R processOperation(long taskId, TTask tTask, List<TaskNode> taskNodes, ZZone zZone, String startPointid, String endPointid) {
+        ManualInfo manualInfo = new ManualInfo();
+        manualInfo.setTaskId(String.valueOf(taskId));
+        manualInfo.setDeviceUnit(zZone.getNo());
+        manualInfo.setStartpointId(startPointid);
+        manualInfo.setEndpointId(endPointid);
+        manualInfo.setRobotResourceId(String.valueOf(taskNodes.get(0).getResourceId()));
+        manualInfo.setManualIdType("general");
+        manualInfo.setHandModeFlag("1");
+        ArrayList robotNodes = new ArrayList();
+        // Plc地址
+        if ("capsule".equals(zZone.getNo())) {
+            robotNodes = robotTaskNodes;
+        } else if ("framework".equals(zZone.getNo())) {
+            robotNodes = robotTaskNodes;
+        } else if ("safeguard".equals(zZone.getNo())) {
+            robotNodes = robotNoMoveTaskNodes;
+        }
+
+        Map<String, Object> processInfo = ManualTaskOperatorUtil.judgeFirstProcessInfo(robotNodes, manualInfo, taskNodes);
+
+        JSONObject returnDataObject = new JSONObject();
 
+        // 组装参数
+        String returnData = "";
+        //组装接口参数
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
+
+        //回调参数构建
+        String deviceUrl = "";
+        String devicePort = "";
+        if ("execProgram".equals(manualInfo.getManualIdType())) {
+            // 机加设备执行程序，直接执行机床接口
+            Productionresource productionresource = productionresourceBizMapper.selectOne(Wraps.<Productionresource>lbQ().eq(Productionresource::getId, manualInfo.getStartResourceId()));
+            deviceUrl = productionresource.getIp();
+            devicePort = productionresource.getPort();
+        }
+        String jsonParam = ManualTaskOperatorUtil.getRequestParam(processInfo.get("location").toString(), manualInfo, "execProgram".equals(manualInfo.getManualIdType()) ? deviceUrl : processInfo.get("deviceUrl").toString(), "execProgram".equals(manualInfo.getManualIdType()) ? devicePort : processInfo.get("devicePort").toString());
+        HttpEntity<String> formEntity = new HttpEntity<String>(jsonParam, headers);
+        //调用接口
+        try {
+            returnData = restTemplate.postForObject(processInfo.get("hostSyetemTaskUrl").toString(), formEntity, String.class);
+            returnDataObject = JSONObject.parseObject(returnData);
+            log.error("调用上位机执行指令返回" + returnData);
+            if ("true".equals(returnDataObject.get("result"))) {
+                // 放入redis，方便回调的时候判断是否是最后一个结点，如果是最后一个结点不在做任何逻辑，更新相应的库位信息
+                Map<String, Object> currentTask = new HashMap<String, Object>();
+                List<String> remindTaskNodes = (List<String>) processInfo.get("remindTaskNodes");
+                currentTask.put("remindRobotNodes", remindTaskNodes);
+                currentTask.put("taskInfo", manualInfo);
+                JSONObject redisTask = new JSONObject();
+                redisTask.putAll(currentTask);
+                msgUtil.redis_set(manualInfo.getTaskId(), redisTask.toJSONString());
+            } else {
+                return R.fail(returnDataObject.getString("msg"));
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            log.error("调用接口发生异常" + e.getMessage());
+            return R.fail(returnDataObject.getString("msg"));
+        }
+        return R.success(returnDataObject);
+    }
 }

imcs-admin-boot/imcs-business-biz/src/main/java/com/github/zuihou/business/util/ManualTaskOperatorUtil.java

@@ -1,8 +1,11 @@
 package com.github.zuihou.business.util;
 
+import cn.hutool.core.collection.CollectionUtil;
 import com.alibaba.fastjson.JSONObject;
 import com.github.zuihou.business.externalApi.dto.ManualInfo;
+import com.github.zuihou.business.operationManagementCenter.entity.TaskNode;
 import com.github.zuihou.business.productionResourceCenter.entity.ProductionresourcePosition;
+import org.apache.commons.lang3.StringUtils;
 
 import java.util.*;
 
@@ -48,8 +51,13 @@ public class ManualTaskOperatorUtil {
         JSONObject jsonParam = new JSONObject();
         jsonParam.put("url",deviceUrl);
         jsonParam.put("port",devicePort);
-        jsonParam.put("taskId",manualInfo.getManualId());
-        jsonParam.put("taskNodeId",manualInfo.getManualId());
+        if(StringUtils.isNotBlank(manualInfo.getTaskId())){
+            jsonParam.put("taskId",manualInfo.getTaskId());
+            jsonParam.put("taskNodeId",manualInfo.getTaskNodeId());
+        }else{
+            jsonParam.put("taskId",manualInfo.getManualId());
+            jsonParam.put("taskNodeId",manualInfo.getManualId());
+        }
         JSONObject data = new JSONObject();
         String manualType = manualInfo.getManualIdType();
 
@@ -80,12 +88,12 @@ public class ManualTaskOperatorUtil {
 
     /**
      * 处理手动模式首次任务结点信息
-     * @param robotTaskNodes
-     * @param robotNoMoveTaskNodes
+     * @param robotNodes
      * @param manualInfo
+     * @param taskNodes
      * @return
      */
-    public static Map<String,Object> judgeFirstProcessInfo(ArrayList<String> robotTaskNodes, ArrayList<String> robotNoMoveTaskNodes , ManualInfo manualInfo){
+    public static Map<String,Object> judgeFirstProcessInfo(ArrayList<String> robotNodes, ManualInfo manualInfo, List<TaskNode> taskNodes){
         Map<String,Object> processInfo = new HashMap<String,Object>();
         String unit = manualInfo.getDeviceUnit();
         String manualType = manualInfo.getManualIdType();
@@ -107,38 +115,53 @@ public class ManualTaskOperatorUtil {
                 // 舱体(智能单元) 代码先写死，6个动作，后续根据resource_code表中获取
                 // 执行第一个任务
                 int currentIndex = 0;
-                String taskType = robotTaskNodes.get(currentIndex);
+                String taskType = robotNodes.get(currentIndex);
+                if(CollectionUtil.isNotEmpty(taskNodes)){
+                    TaskNode taskNode = taskNodes.get(currentIndex);
+                    manualInfo.setTaskNodeId(String.valueOf(taskNode.getId()));
+                    manualInfo.setTaskNode(taskNode);
+                }
                 int nextTaskNodeIndex = currentIndex +1;
                 if("move".equals(taskType)){
                     String hostSyetemTaskUrl = hostSyetemUrl + "/api/MoveRobotPosition";
                     String location = manualInfo.getStartpointId();
-                    setProcessInfo(robotTaskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                    setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                 }
-                if(nextTaskNodeIndex < robotTaskNodes.size() -1){
+                if(nextTaskNodeIndex < robotNodes.size() -1){
                     manualInfo.setNextTaskNodeIndex(nextTaskNodeIndex);
                 }
             }else if("framework".equals(unit)){
                 int currentIndex = 0;
-                String taskType = robotTaskNodes.get(currentIndex);
+                String taskType = robotNodes.get(currentIndex);
+                if(CollectionUtil.isNotEmpty(taskNodes)){
+                    TaskNode taskNode = taskNodes.get(currentIndex);
+                    manualInfo.setTaskNodeId(String.valueOf(taskNode.getId()));
+                    manualInfo.setTaskNode(taskNode);
+                }
                 int nextTaskNodeIndex = currentIndex +1;
                 if("move".equals(taskType)){
                     String hostSyetemTaskUrl = hostSyetemUrl + "/api/MoveRobotPosition";
                     String location = manualInfo.getStartpointId();
-                    setProcessInfo(robotTaskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                    setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                 }
-                if(nextTaskNodeIndex < robotTaskNodes.size() -1){
+                if(nextTaskNodeIndex < robotNodes.size() -1){
                     manualInfo.setNextTaskNodeIndex(nextTaskNodeIndex);
                 }
             }else if("safeguard".equals(unit)){
                 // 保障平台(质量中心) 代码先写死，6个动作，后续根据resource_code表中获取
                 // 执行第一个任务
                 int currentIndex = 0;
-                String taskType = robotNoMoveTaskNodes.get(currentIndex);
+                String taskType = robotNodes.get(currentIndex);
+                if(CollectionUtil.isNotEmpty(taskNodes)){
+                    TaskNode taskNode = taskNodes.get(currentIndex);
+                    manualInfo.setTaskNodeId(String.valueOf(taskNode.getId()));
+                    manualInfo.setTaskNode(taskNode);
+                }
                 int nextTaskNodeIndex = currentIndex +1;
                 if("get".equals(taskType)){
                     String hostSyetemTaskUrl = hostSyetemUrl + "/api/GetServoStacker";
                     String location = manualInfo.getStartpointId();
-                    setProcessInfo(robotNoMoveTaskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                    setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                 }
                 manualInfo.setNextTaskNodeIndex(nextTaskNodeIndex);
             }
@@ -195,11 +218,11 @@ public class ManualTaskOperatorUtil {
 
     /**
      * 处理手动模式回调任务结点信息
-     * @param taskNodes
+     * @param robotNodes
      * @param manualInfo
      * @return
      */
-    public static Map<String,Object> judgeProcessInfo(ArrayList<String> taskNodes, ManualInfo manualInfo, List<ProductionresourcePosition> productionresourcePositions){
+    public static Map<String,Object> judgeProcessInfo(ArrayList<String> robotNodes, ManualInfo manualInfo, List<ProductionresourcePosition> productionresourcePositions){
         String unit = manualInfo.getDeviceUnit();
         String manualType = manualInfo.getManualIdType();
         Map<String,Object> processInfo = new HashMap<String,Object>();
@@ -222,103 +245,103 @@ public class ManualTaskOperatorUtil {
             if("capsule".equals(unit)){
                 int currentIndex = manualInfo.getNextTaskNodeIndex();
                 int nextTaskNodeIndex = currentIndex +1;
-                String taskType = taskNodes.get(currentIndex);
+                String taskType = robotNodes.get(currentIndex);
 
-                if(taskNodes.size() == 6){
+                if(robotNodes.size() == 6){
                     // 舱体(柔性线) 代码先写死，6个动作，后续根据resource_code表中获取
                     // 执行第一个任务
                     if("get".equals(taskType) && currentIndex == 1){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/GetFlexibleWire";
                         String location = manualInfo.getStartpointId();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }else if("put".equals(taskType) && currentIndex == 2){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/SendFlexibleWire";
                         productionresourcePositions = productionresourcePositions.stream().filter(p->null == p.getGoodsId() && "1".equals(p.getLockStatus())).collect(toList());
 
                         String location = productionresourcePositions.get(0).getPointId().toString();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }else if("move".equals(taskType) && currentIndex == 3){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/MoveRobotPosition";
                         String location = manualInfo.getEndpointId();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }if("get".equals(taskType) && currentIndex == 4){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/GetFlexibleWire";
                         productionresourcePositions = productionresourcePositions.stream().filter(p->null == p.getGoodsId()  && "1".equals(p.getLockStatus())).collect(toList());
 
                         String location = productionresourcePositions.get(0).getPointId().toString();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }else if("put".equals(taskType) && currentIndex == 5){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/SendFlexibleWire";
                         String location = manualInfo.getEndpointId();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }
                     manualInfo.setNextTaskNodeIndex(nextTaskNodeIndex);
-                }else if(taskNodes.size() == 3 && currentIndex == 1){
+                }else if(robotNodes.size() == 3 && currentIndex == 1){
                     if("get".equals(taskType) ){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/GetFlexibleWire";
                         String location = manualInfo.getStartpointId();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }else if("put".equals(taskType) && currentIndex == 2){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/SendFlexibleWire";
                         String location = manualInfo.getEndpointId();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }
                 }
             }else if("framework".equals(unit)){
                 int currentIndex = manualInfo.getNextTaskNodeIndex();
                 int nextTaskNodeIndex = currentIndex +1;
-                String taskType = taskNodes.get(currentIndex);
+                String taskType = robotNodes.get(currentIndex);
 
-                if(taskNodes.size() == 6){
+                if(robotNodes.size() == 6){
                     // 舱体(柔性线) 代码先写死，6个动作，后续根据resource_code表中获取
                     // 执行第一个任务
                     if("get".equals(taskType) && currentIndex == 1){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/GetFlexibleWire";
                         String location = manualInfo.getStartpointId();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }else if("put".equals(taskType) && currentIndex == 2){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/SendFlexibleWire";
                         productionresourcePositions = productionresourcePositions.stream().filter(p->null == p.getGoodsId() && "1".equals(p.getLockStatus())).collect(toList());
 
                         String location = productionresourcePositions.get(0).getPointId().toString();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }else if("move".equals(taskType) && currentIndex == 3){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/MoveRobotPosition";
                         String location = manualInfo.getEndpointId();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }if("get".equals(taskType) && currentIndex == 4){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/GetFlexibleWire";
                         productionresourcePositions = productionresourcePositions.stream().filter(p->null == p.getGoodsId()  && "1".equals(p.getLockStatus())).collect(toList());
 
                         String location = productionresourcePositions.get(0).getPointId().toString();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }else if("put".equals(taskType) && currentIndex == 5){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/SendFlexibleWire";
                         String location = manualInfo.getEndpointId();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }
                     manualInfo.setNextTaskNodeIndex(nextTaskNodeIndex);
-                }else if(taskNodes.size() == 3){
+                }else if(robotNodes.size() == 3){
                     if("get".equals(taskType) && currentIndex == 1){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/GetFlexibleWire";
                         String location = manualInfo.getStartpointId();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }else if("put".equals(taskType) && currentIndex == 2){
                         String hostSyetemTaskUrl = hostSyetemUrl + "/api/SendFlexibleWire";
                         String location = manualInfo.getEndpointId();
-                        setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                        setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                     }
                 }
             }else if("safeguard".equals(unit)){
                 int currentIndex = manualInfo.getNextTaskNodeIndex();
                 int nextTaskNodeIndex = currentIndex +1;
-                String taskType = taskNodes.get(currentIndex);
+                String taskType = robotNodes.get(currentIndex);
                 // 保障平台(质量中心)
                 // 执行第一个任务
                 if("put".equals(taskType)){
                     String hostSyetemTaskUrl = hostSyetemUrl + "/api/SendServoStacker";
                     String location = manualInfo.getEndpointId();
-                    setProcessInfo(taskNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
+                    setProcessInfo(robotNodes, processInfo, hostSyetemTaskUrl, location, deviceUrl, devicePort);
                 }
                 manualInfo.setNextTaskNodeIndex(nextTaskNodeIndex);
             }
@@ -328,18 +351,18 @@ public class ManualTaskOperatorUtil {
 
     /**
      *
-     * @param taskNodes
+     * @param robotNodes
      * @param processInfo
      * @param hostSyetemTaskUrl
      * @param location
      * @param deviceUrl
      * @param devicePort
      */
-    private static void setProcessInfo(ArrayList<String> taskNodes, Map<String, Object> processInfo, String hostSyetemTaskUrl, String location, String deviceUrl, String devicePort) {
+    private static void setProcessInfo(ArrayList<String> robotNodes, Map<String, Object> processInfo, String hostSyetemTaskUrl, String location, String deviceUrl, String devicePort) {
         processInfo.put("hostSyetemTaskUrl", hostSyetemTaskUrl);
         processInfo.put("deviceUrl", deviceUrl);
         processInfo.put("devicePort", devicePort);
         processInfo.put("location", location);
-        processInfo.put("remindTaskNodes", taskNodes);
+        processInfo.put("remindRobotNodes", robotNodes);
     }
 }

imcs-admin-boot/imcs-business-controller/src/main/java/com/github/zuihou/business/controller/operationManagementCenter/WorkpieceController.java

@@ -140,7 +140,7 @@ public class WorkpieceController extends SuperController<WorkpieceService, Long,
 
     @ApiOperation(value = "根据点位查询手动模式信息", notes = "根据点位查询手动模式信息")
     @PostMapping("/handMode/getOrderInfo")
-    public R<List>  getOrderInfo(@RequestBody Map paraMap) {
+    public R<List>  getOrderInfo(@RequestBody Map zh) {
         List list = baseService.getOrderInfo();
         return success(list);
     }
@@ -156,8 +156,13 @@ public class WorkpieceController extends SuperController<WorkpieceService, Long,
 
     @ApiOperation(value = "订单执行", notes = "订单执行")
     @PostMapping("/handMode/executeOrder")
-    public R<String>  executeOrder(@RequestBody Map paraMap) {
-        return success("");
+    public R executeOrder(@RequestBody Map paraMap) {
+        // 判断请求参数是否完整
+        String taskId = paraMap.get("taskId")==null?"":paraMap.get("taskId").toString();
+        if(StringUtils.isBlank(taskId) ){
+            return R.fail("请求参数不完整");
+        }
+        return baseService.executeOrder(paraMap);
     }
 
 

imcs-admin-boot/imcs-business-entity/src/main/java/com/github/zuihou/business/externalApi/dto/ManualInfo.java

@@ -1,5 +1,6 @@
 package com.github.zuihou.business.externalApi.dto;
 
+import com.github.zuihou.business.operationManagementCenter.entity.TaskNode;
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.*;
@@ -97,4 +98,10 @@ public class ManualInfo {
      * 手动模式标志1-手动
      */
     private String handModeFlag;
+
+    private String taskId;
+
+    private String taskNodeId;
+
+    private TaskNode taskNode;
 }

imcs-admin-boot/imcs-common/src/main/java/com/github/zuihou/common/constant/UrlConfConstant.java

@@ -11,18 +11,33 @@ public interface UrlConfConstant {
 
         public String url = "http://127.0.0.1:8764/task/testTask";
 
-        public String plcURL = "http://192.168.170.202:8089";
+//        public String plcURL = "http://192.168.170.202:8089";
 
         public String agvURL = "http://localhost:9099/api/authority/mock/mockWms";
-        //质量中心
-        public String ZK_ip_zlzx = "192.168.170.61";
-        //柔性
-        public String ZK_ip_rxx = "192.168.170.71";
-        //智能单元
-        public String ZK_ip_zndy = "192.168.170.81";
+//        //质量中心
+//        public String ZK_ip_zlzx = "192.168.170.61";
+//        //柔性
+//        public String ZK_ip_rxx = "192.168.170.71";
+//        //智能单元
+//        public String ZK_ip_zndy = "192.168.170.81";
 
         //总控端口
         public String ZK_port = "120";
-
-
+        /**
+         * 上位机模拟程序接口
+         */
+        public String plcURL = "http://106.15.38.8:8090";
+
+        /**
+         * 保障平台
+         */
+        public static String ZK_ip_zlzx = "192.168.170.130";
+        /**
+         * 框体
+         */
+        public static String ZK_ip_rxx = "192.168.170.170";
+        /**
+         * 舱体
+         */
+        public static String ZK_ip_zndy = "192.168.170.150";
 }