增加上片模块线程，增加保存工程时的已保存判断

wu

2024-05-10 a8e32b8a10bb462bb01f37e3b03d9d9fc3ffdee5

增加上片模块线程，增加保存工程时的已保存判断

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/engineering/service/EngineeringService.java

@@ -23,4 +23,6 @@
    List<Engineering> selectEngineering(String engineeringId);

    void saveEngineering(List<Engineering> engineerings);

    Engineering selectInitiate(Integer state);
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/engineering/service/impl/EngineeringServiceImpl.java

@@ -81,6 +81,15 @@
    @Override
    public void saveEngineering(List<Engineering> engineerings) {
        this.saveBatch(engineerings);
        //保存钢化工程信息
    }

    @Override
    public  Engineering selectInitiate(Integer state) {
        //查询是否有开始上片的工程任务
        QueryWrapper<Engineering> wrapper = new QueryWrapper<>();
            wrapper.eq("state", state);
        return this.getOne(wrapper);
    }

}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/controller/OptimizeProjectController.java

@@ -41,16 +41,16 @@
        return Result.build(200, "", glass);
    }

    @ApiOperation("保存工程信息")
    @PostMapping("/saveProject") //显示工程选择信息
    public Result<List<OptimizeProject>> saveProject(@RequestBody OptimizeRequest optimizeRequest) {
        log.info("获取选择好的工程id进行查询数据后保存");
        List<OptimizeProject> glass = optimizeProjectService.selectSaveProject(optimizeRequest);
        log.info("显示工程选择信息后保存到upPattenUsage表:{}", glass);
        optimizeProjectService.insetupPattenUsage(glass);
        //void insetProject(glass);
        return Result.build(200, "", glass);
    }
//    @ApiOperation("保存工程信息")
//    @PostMapping("/saveProject") //显示工程选择信息
//    public Result<List<OptimizeProject>> saveProject(@RequestBody OptimizeRequest optimizeRequest) {
//        log.info("获取选择好的工程id进行查询数据后保存");
//        List<OptimizeProject> glass = optimizeProjectService.selectSaveProject(optimizeRequest);
//        log.info("显示工程选择信息后保存到upPattenUsage表:{}", glass);
//        optimizeProjectService.insetupPattenUsage(glass);
//        //void insetProject(glass);
//        return Result.build(200, "", glass);
//    }

}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/service/OptimizeProjectService.java

@@ -23,13 +23,13 @@
     */
    List<OptimizeProject> listByState(OptimizeRequest optimizeRequest);
    /**
     * 查询保存到原片使用详情表的数据
     * @return
     */
    List<OptimizeProject> selectSaveProject(OptimizeRequest optimizeRequest);
    /**
     * 将工程信息保存到原片使用详情表
     * @return
     */
    void insetupPattenUsage(List<OptimizeProject> glass);
    /**
     * 将工程信息更新状态为已领取
     * @return
     */
    void changeTask(String engineeringId, int i);
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/service/impl/OptimizeProjectServiceImpl.java

@@ -2,8 +2,8 @@

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.mes.pp.entity.OptimizeProject;
import com.mes.pp.entity.request.OptimizeRequest;
@@ -15,7 +15,6 @@
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;

/**
@@ -59,11 +58,15 @@
    }

    @Override
    public List<OptimizeProject> selectSaveProject(OptimizeRequest optimizeRequest) {
        log.info("将参数传入到查询类里,工程号做非空判断模糊查询");
    public void changeTask(String engineeringId, int state) {
        UpdateWrapper<OptimizeProject> wrapper = new UpdateWrapper<>();
        wrapper.eq("project_no",engineeringId)
                .set("state",state);
        boolean updateSuccess = this.update(wrapper);
        log.info("工程表更新状态{}",updateSuccess);

        log.info("返回工程信息");
        return this.baseMapper.saveProject(optimizeRequest);
    }



}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/uppattenusage/controller/UpPattenUsageController.java

@@ -2,6 +2,8 @@
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.service.EngineeringService;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.pp.entity.OptimizeProject;
import com.mes.pp.service.OptimizeProjectService;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.uppattenusage.service.UpPattenUsageService;
@@ -34,6 +36,8 @@
    private  GlassInfoService glassInfoService;
    @Autowired
    private  EngineeringService engineeringService;
    @Autowired
    private OptimizeProjectService optimizeProjectService;
    @ApiOperation("显示正在出片的工程信息")
    @GetMapping("/prioritylist") //查询现在上片机的玻璃信息
    public Result<List<UpPattenUsage>> prioritylist() {
@@ -45,16 +49,26 @@
    @ApiOperation("点击选择工程保存后进行调用,传入工程号")
    @GetMapping("/saveUpPattenUsage") //查询现在上片机的玻璃信息
    public Result<Integer> saveUpPattenUsage(String engineeringId) {
        List<UpPattenUsage> upPattenUsages = upPattenUsageService.selectSaveUpPattenUsage(engineeringId);
        log.info("将查询出的UpPattenUsage数据保存到数据库表里");
        upPattenUsageService.saveUpPattenUsage(upPattenUsages);
        log.info("从PP表查询glassinfo的数据并保存到表里");
        List<GlassInfo> glassinfo=glassInfoService.selectGlassInfo(engineeringId);
        glassInfoService.saveGlassInfo(glassinfo);
        log.info("从PP表查询engineering的数据并保存到表里");
        List<Engineering> engineerings= engineeringService.selectEngineering(engineeringId);
        engineeringService.saveEngineering(engineerings);
        return Result.build(200, "", 200);
        log.info("传入工程号判断是否已保存:{}", engineeringId);
        UpPattenUsage upPattenUsage= upPattenUsageService.selectedEngineering(engineeringId);
        if (upPattenUsage!=null){
            log.info("已保存过");
            return Result.build(200, "已保存过", 200);
        }else {
            List<UpPattenUsage> upPattenUsages = upPattenUsageService.selectSaveUpPattenUsage(engineeringId);
            log.info("将查询出的UpPattenUsage数据保存到数据库表里");
            upPattenUsageService.saveUpPattenUsage(upPattenUsages);
            log.info("从PP表查询glassinfo的数据并保存到表里");
            List<GlassInfo> glassinfo=glassInfoService.selectGlassInfo(engineeringId);
            glassInfoService.saveGlassInfo(glassinfo);
            log.info("从PP表查询engineering的数据并保存到表里");
            List<Engineering> engineerings= engineeringService.selectEngineering(engineeringId);
            engineeringService.saveEngineering(engineerings);
            log.info("更改pp表状态为已领取");
            optimizeProjectService.changeTask(engineeringId, 200);
            return Result.build(200, "", 200);
        }

    }
}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/uppattenusage/service/UpPattenUsageService.java

@@ -19,5 +19,10 @@
     List<UpPattenUsage> selectSaveUpPattenUsage(String engineeringId);

     void saveUpPattenUsage(List<UpPattenUsage> upPattenUsages);

     void updateupPattenUsageState(UpPattenUsage upPattenUsage, Integer state);

     UpPattenUsage selectedEngineering(String engineeringId);

}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/uppattenusage/service/impl/UpPattenUsageServiceImpl.java

@@ -2,6 +2,7 @@

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.query.MPJQueryWrapper;
import com.mes.pp.entity.OptimizeProject;
@@ -63,7 +64,7 @@
                optimizeProject.setFilmsId( map.getGlassType());
                optimizeProject.setWidth(map.getWidth());
                optimizeProject.setHeight( map.getHeight());
                optimizeProject.setThickness(map.getHeight());
                optimizeProject.setThickness(map.getGlassThickness());
                optimizeProject.setLayoutSequence( map.getStockId());
                optimizeProject.setState(0);
                // 将映射后的对象添加到结果列表中
@@ -80,7 +81,21 @@
        //保存原片使用详情表
    }

    @Override
    public void updateupPattenUsageState(UpPattenUsage upPattenUsage, Integer state) {
        upPattenUsage.setState(state);
        boolean updateSuccess=this.updateById(upPattenUsage);
        log.info("更新状态{}",updateSuccess);
        //更新状态
    }

    @Override
    public UpPattenUsage selectedEngineering(String engineeringId) {
        QueryWrapper<UpPattenUsage>wrapper = new QueryWrapper<>();
        wrapper.eq("engineering_id",engineeringId)
                .last("limit 1");
        return this.getOne(wrapper);
    }


}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/AppRunnerConfig.java

New file
@@ -0,0 +1,29 @@
package com.mes;

import com.mes.common.S7object;
import com.mes.job.PlcLoadGlassTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Order(1)

public class AppRunnerConfig implements ApplicationRunner {

    private final PlcLoadGlassTask plcLoadGlassTask;

    public AppRunnerConfig(PlcLoadGlassTask plcLoadGlassTask) {
        this.plcLoadGlassTask = plcLoadGlassTask;
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("启动完成");
        S7object.getinstance().start();

    }
}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/LoadGlassModuleApplication.java

@@ -5,6 +5,7 @@
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.scheduling.annotation.EnableScheduling;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
@@ -16,6 +17,7 @@
@SpringBootApplication
@EnableSwagger2
@EnableDiscoveryClient
@EnableScheduling
@MapperScan(basePackages = "com.mes.*.mapper")
public class LoadGlassModuleApplication {
    public static void main(String[] args) {

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/common/JsonFile/PlcLoadGlass.json

File was deleted

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/common/S7object.java

@@ -1,24 +1,34 @@
package com.mes.common;

import com.github.xingshuangs.iot.protocol.s7.enums.EPlcType;
import com.mes.device.PlcParameterObject;
import com.mes.tools.InitUtil;
import com.mes.tools.S7control;



/**
 * @Author : zhoush
 * @Date: 2024/4/9 15:13
 * @Description:
 */
public class S7object {
public class S7object extends Thread {
    public S7control plccontrol; // PLC通讯类实例
    private EPlcType plcType = EPlcType.S1500; // 西门子PLC类型
    private EPlcType plcType = EPlcType.S1200; // 西门子PLC类型
    private String ip = "192.168.10.1"; // plc ip地址
    private int port = 102; // plc 端口号


    public PlcParameterObject PlcMesObject;
    private static volatile S7object instance = null;

    private S7object() {
        if (plccontrol == null) {
            plccontrol = new S7control(plcType, ip, port, 0, 0);

            String PlcLoadGlass=S7object.class.getResource("/JsonFile/PlcLoadGlass.json").getPath();
            //log.info(PLCAutoMes.class.getResource("").getPath());
            PlcMesObject = InitUtil.initword(PlcLoadGlass);
        }
    }

@@ -33,4 +43,20 @@
        }
        return instance;
    }

    @Override
    public void run() {
        while (this != null) {
            try {
                Thread.sleep(100);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            byte[] getplcvlues=   plccontrol.ReadByte(PlcMesObject.getPlcAddressBegin(),PlcMesObject.getPlcAddressLength());
            PlcMesObject.setPlcParameterList(getplcvlues);

        }
    }
}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/common/WebSocketServer.java

New file
@@ -0,0 +1,160 @@
package com.mes.common;

import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@ServerEndpoint(value = "/api/talk/{username}")
@Component("webSocketServer")
public class WebSocketServer {


    public static ConfigurableApplicationContext applicationContext;

    // 解决无法注入mapper问题 //使用方法
    // homeMapper=WebSocketServer.applicationContext.getBean(HomeMapper.class);
    public static void setApplicationContext(ConfigurableApplicationContext configurableApplicationContext) {
        WebSocketServer.applicationContext = configurableApplicationContext;
    }

    private static final Logger log = LoggerFactory.getLogger(WebSocketServer.class);
    private List<String> messages;
    /**
     * 记录当前在线连接数
     */
    public static final Map<String, ArrayList<WebSocketServer>> sessionMap = new ConcurrentHashMap<>();

    String username;
    Session session;

    public WebSocketServer() {
        this.messages = new ArrayList<>();
    }

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("username") String username) {
        this.username = username;
        this.session = session;
        List<WebSocketServer> webSocketServers = sessionMap.get(username);
        if (webSocketServers == null) {
            ArrayList<WebSocketServer> arrayListwebserver = new ArrayList<WebSocketServer>();
            arrayListwebserver.add(this);
            sessionMap.put(username, arrayListwebserver);
        } else {
            webSocketServers.add(this);
        }

        log.info("有新用户加入，username={}, 当前在线人数为：{}", username, sessionMap.get(username).size());

        // JSONObject result = new JSONObject();
        // JSONArray array = new JSONArray();
        // result.set("users", array);
        // for (Object key : sessionMap.keySet()) {
        // JSONObject jsonObject = new JSONObject();
        // jsonObject.set("username", key);
        // array.add(jsonObject);
        // }

        // sendAllMessage(JSONUtil.toJsonStr(result)); // 后台发送消息给所有的客户端
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose(Session session, @PathParam("username") String username) {
        List<WebSocketServer> webSocketServers = sessionMap.get(username);
        ArrayList<WebSocketServer> arrayListwebserver = new ArrayList<WebSocketServer>();
        if (webSocketServers.size() > 1) {
            for (WebSocketServer webSocketServer : webSocketServers) {
                if (webSocketServer != this) {
                    arrayListwebserver.add(webSocketServer);
                }
            }
            sessionMap.put(username, arrayListwebserver);
            log.info("移除username={}一名用户session, {}的当前在线人数为：{}", username, username, sessionMap.get(username).size());
        } else {
            sessionMap.remove(username);
            log.info("移除username={}一名用户session, {}连接关闭, 当前连接数为：{}", username, username, sessionMap.size());
        }

    }

    /**
     * 收到客户端消息后调用的方法
     * 后台收到客户端发送过来的消息
     * onMessage 是一个消息的中转站
     * 接受 浏览器端 socket.send 发送过来的 json数据
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, Session session, @PathParam("username") String username) {
        log.info("服务端收到用户username={}的消息:{}", username, message);
        JSONObject obj = JSONUtil.parseObj(message);
        String text = obj.getStr("data");

        JSONObject jsonObject = new JSONObject();
        jsonObject.set("message", text);
        this.messages.add(text);
        this.sendMessage(jsonObject.toString()); // JSONUtil.toJsonStr(jsonObject)

    }

    @OnError
    public void onError(Session session, Throwable error) {
        log.error("发生错误");
        error.printStackTrace();
    }

    /**
     * 服务端发送消息给客户端
     */
    public void sendMessage(String message) {
        try {
            // log.info("服务端给客户端[{}]发送消息{}", this.session.getId(), message);
            this.session.getBasicRemote().sendText(message);
        } catch (Exception e) {
            log.error("服务端发送消息给客户端失败", e);
        }
    }

    // /**
    //  * 服务端发送消息给所有客户端
    //  */
    // public void sendAllMessage(String message) {
    //     try {
    //         for (WebSocketServer webSocketServer : sessionMap.values()) {
    //             // log.info("服务端给客户端[{}]发送消息{}", this.session.getId(), message);
    //             webSocketServer.sendMessage(message);
    //         }
    //     } catch (Exception e) {
    //         log.error("服务端发送消息给客户端失败", e);
    //     }
    // }

    public List<String> getMessages() {
        return messages;

    }

    public void clearMessages() {
        messages.clear();
    }


}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/job/PlcLoadGlassTask.java

@@ -1,33 +1,113 @@
package com.mes.job;

import cn.hutool.json.JSONObject;
import com.mes.common.S7object;
import com.mes.device.PlcParameterObject;
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.service.EngineeringService;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.uppattenusage.service.UpPattenUsageService;
import com.mes.workstation.entity.UpWorkstation;
import com.mes.workstation.service.UpWorkstationService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

/**
 * @author SNG-010
 */
@Component
@Slf4j
public class PlcLoadGlassTask {

    @Autowired
    private UpWorkstationService upWorkstationService;
    @Autowired
    private EngineeringService  engineeringService;
    @Autowired
    private UpPattenUsageService upPattenUsageService;


    PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
    /**
     * fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
     * fixedDelay : 上一个调用结束后再次调用的延时
     */

    @Scheduled(fixedDelay = 300)
    public void plcLoadGlassTask() throws InterruptedException {
        JSONObject jsonObject = new JSONObject();
        try {
            Thread.sleep(300);
            upWorkstationService.selectPriority();
            log.info("开始上片");
            //获取是否有上片请求
            String loadRequest = plcParameterObject.getPlcParameter("loadRequest").getValue();
            //判断开始上片的工程号
            Engineering engineering=engineeringService.selectInitiate(1);
            if("1".equals(loadRequest)&&engineering!=null){
                UpPattenUsage upPattenUsage=upWorkstationService.selectPriority(engineering);
                log.info("当有请求时查询当前上片顺序的玻璃信息{}",upPattenUsage);
                UpWorkstation upwork=upWorkstationService.selectworkstation(upPattenUsage);
                log.info("符合的尺寸的工位玻璃：{}",upwork);
                if(upwork!=null){
                    int workId=upwork.getWorkstationId();//工位id
                    double width=upwork.getPatternWidth();//宽度
                    double height=upwork.getPatternHeight();//高度
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("WorkId").getAddress(),workId);
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("GlassWidth").getAddress(), (long) width);
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("GlassHeight").getAddress(), (long) height);
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlc").getAddress(),1);
                    //减少工位数量
                    upWorkstationService.reduceWorkstationNumber(upwork);
                    //完成上片表状态
                    upPattenUsageService.updateupPattenUsageState(upPattenUsage,1);

                }
            }
            //获取是否有汇报
            String loadStatus = plcParameterObject.getPlcParameter("PlcStatus").getValue();
            if (loadStatus!=null) {
                log.info(loadStatus);
                if ("1".equals(loadStatus)) {
                    log.info("收到汇报任务完成");
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(), 1);
                } else if ("2".equals(loadStatus)) {
                    log.info("收到汇报未完成任务");
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(), 1);
                } else if ("3".equals(loadStatus)) {
                    log.info("收到汇报玻璃破损");
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(), 1);
                } else {
                    log.info("收到汇报清0状态");
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(), 0);
                }
            }
            //执行后休眠300毫秒
            //Thread.sleep(300);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
//    @Scheduled(fixedDelay = 300)
//    public void plcLoadGlassOver() throws InterruptedException {
//        try {
//            //获取是否有汇报
//            String loadStatus = plcParameterObject.getPlcParameter("PlcStatus").getValue();
//            if ("1".equals(loadStatus)){
//                log.info("收到汇报任务完成");
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(),1);
//            }else if ("2".equals(loadStatus)) {
//                log.info("收到汇报未完成任务");
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(),1);
//            }else if("3".equals(loadStatus)){
//                log.info("收到汇报玻璃破损");
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(),1);
//            }else {
//                log.info("收到汇报清0状态");
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(),0);
//            }
//
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }

}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/workstation/entity/UpWorkstation.java

@@ -56,7 +56,7 @@
    /**
     * 原片高
     */
    private Double patternHeigth;
    private Double patternHeight;

    /**
     * 原片厚度

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/workstation/service/UpWorkstationService.java

@@ -1,6 +1,8 @@
package com.mes.workstation.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.engineering.entity.Engineering;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.workstation.entity.UpWorkSequence;
import com.mes.workstation.entity.UpWorkstation;

@@ -17,10 +19,12 @@



    //判断优先吸片位置后发送出片任务
    UpWorkSequence selectPriority();

    //查询正在进行的工程
    //判断优先吸片玻璃
    UpPattenUsage selectPriority(Engineering engineering);
    //查询正在进行的单片信息
    UpWorkstation selectworkstation(UpPattenUsage upPattenUsage);
    //减少工位数量
    void reduceWorkstationNumber(UpWorkstation upwork);


    /**

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/workstation/service/impl/UpWorkstationServiceImpl.java

@@ -1,7 +1,9 @@
package com.mes.workstation.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.engineering.entity.Engineering;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.uppattenusage.mapper.UpPattenUsageMapper;
import com.mes.workstation.entity.UpWorkSequence;
@@ -27,36 +29,47 @@
public class UpWorkstationServiceImpl extends ServiceImpl<UpWorkstationMapper, UpWorkstation> implements UpWorkstationService {
    @Resource
    UpPattenUsageMapper upPattenUsageMapper;
    public static final String DB_100_10 = "DB_100_10";

    //判断是否可以吸片进行任务
    public boolean isCanLoadGlass() {
        String loadstart = "吸片信号";//plcmes.getPlcParameter("吸片信号").getValue();
        return "1".equals(loadstart);

    }
    //显示正在进行任务的工程信息
    @Resource
    UpWorkstationMapper upWorkstationMapper;


    //判断优先吸片位置后发送出片任务

    public UpWorkSequence selectPriority() {
        UpWorkSequence upwork= this.baseMapper.selectPriority(1);
        String start = "1";//plcmes.getPlcParameter("吸片信号").getValue();
        UpPattenUsage uplist=new UpPattenUsage();
        if(start.equals("1")){
            //发送出片任务
            UpdateWrapper<UpPattenUsage> updateWrapper = new UpdateWrapper<>();
            updateWrapper.eq("state",1).last("LIMIT 1");
            uplist= upPattenUsageMapper.selectOne(updateWrapper);
            log.info("查询出本次出片的玻璃信息[]",uplist);
        }
        return upwork;
    public UpPattenUsage selectPriority(Engineering engineering) {
        QueryWrapper<UpPattenUsage> wrapper=new QueryWrapper<>();
        wrapper.eq("state", 0)
                .eq("engineering_id",engineering.getEngineerId())
                .orderByAsc("layout_sequence")
                .last("limit 1");
        return upPattenUsageMapper.selectOne(wrapper);
    }

    //判断工位是否有符合条件的玻璃
    @Override
    public UpWorkstation selectworkstation(UpPattenUsage upPattenUsage) {
        QueryWrapper<UpWorkstation> wrapper = new QueryWrapper<>();
        wrapper.eq("pattern_width", upPattenUsage.getWidth())
                .eq("pattern_height", upPattenUsage.getHeight())
                .eq("pattern_thickness", upPattenUsage.getThickness())
                .eq("films_id", upPattenUsage.getFilmsId())
                .gt("number", 0)
                .orderByAsc("number")
                .last("limit 1");
        return this.baseMapper.selectOne(wrapper);
    }

    @Override
    public void reduceWorkstationNumber(UpWorkstation upwork) {
        UpdateWrapper<UpWorkstation> wrapper = new UpdateWrapper<>();
        wrapper.eq("id", upwork.getWorkstationId())
                .setSql("number = number - 1");
        boolean updateResult = upWorkstationMapper.update(null, wrapper) > 0;
        log.info("减少工位数量{}",updateResult);

    }

    /**
     * 增加人工输入的工位玻璃信息/删除人工搬走的玻璃信息
     * @param upwork
     */
    @Override
    public void updateGlassMessage(UpWorkstation upwork) {

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/resources/JsonFile/PlcLoadGlass.json

@@ -4,7 +4,7 @@
  "dataType":"word",
  "parameteInfor":[
    {
      "codeId": "PlcToMes",
      "codeId": "loadRequest",
      "addressIndex":"0",
      "addressLenght":"2",
      "ratio":"1",

 hangzhoumesParent/moduleService/LoadGlassModule/src/test/java/com/mes/LoadGlassModuleApplicationTest.java

@@ -5,8 +5,11 @@
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.pp.mapper.OptimizeProjectMapper;
import com.mes.pp.service.OptimizeProjectService;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.uppattenusage.service.impl.UpPattenUsageServiceImpl;
import com.mes.workstation.entity.UpWorkstation;
import com.mes.workstation.service.UpWorkstationService;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -34,6 +37,10 @@
    private GlassInfoService glassInfoService;
    @Autowired
    private EngineeringService engineeringService;
    @Autowired
    private UpWorkstationService workstationService;
    @Autowired
    private OptimizeProjectService optimizeProjectService;
    @Test
    public void test() {
//        List<OptimizeProject> list = optimizeProjectMapper.saveProject("P24032204");
@@ -48,9 +55,18 @@

    @Test
    public void testFindPa() {
        List<UpPattenUsage> glass = upPattenUsageService.selectSaveUpPattenUsage("P24032204");
        log.info("完整路径：{}", Arrays.asList(glass));
        Engineering  engineering= engineeringService.selectInitiate(1);
        log.info("开始上片的工程：{}", Arrays.asList(engineering));
        UpPattenUsage upPattenUsage = workstationService.selectPriority(engineering);
        log.info("上片顺序：{}", Arrays.asList(upPattenUsage));
        UpWorkstation glass2=workstationService.selectworkstation(upPattenUsage);
        log.info("符合的工位玻璃{}",glass2);
        workstationService.reduceWorkstationNumber(glass2);
        //减少数量
        upPattenUsageService.updateupPattenUsageState(upPattenUsage,1);
        //更新状态
    }

    @Test
    public  void  textglassinfo(){
        List<GlassInfo> glass= glassInfoService.selectGlassInfo("P24032204");
@@ -63,4 +79,14 @@
        engineeringService.saveEngineering(glass);
        log.info("glassinfo：{}", Arrays.asList(glass));
    }
    @Test
    public  void  textengineering2(){
        //更新工程表状态为已领取
        optimizeProjectService.changeTask("P24050801",200);
    }
    @Test
    public  void  textengineering3(){
        //判断是否已保存过工程号到上片表
        upPattenUsageService.selectedEngineering("P24050801");
    }
}