初始化

.classpath

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+    <classpathentry kind="src" path="image"/>
+	<classpathentry excluding="resources/" kind="src" path="src"/>
+	<classpathentry kind="src" path="src/resources"/>
+	<classpathentry kind="output" path="bin"/>
+	<classpathentry kind="lib" path="lib/s7connector-2.1.jar"/>
+	<classpathentry kind="lib" path="lib/slf4j-api-2.0.6.jar"/>
+	<classpathentry kind="lib" path="lib/okhttp-4.10.0.jar"/>
+	<classpathentry kind="lib" path="lib/kotlin-stdlib-1.8.10.jar"/>
+	<classpathentry kind="lib" path="lib/okio-jvm-3.3.0.jar"/>
+	<classpathentry kind="lib" path="lib/gson-2.10.jar"/>
+	<classpathentry kind="lib" path="lib/jfreechart-1.5.4.jar"/>
+	<classpathentry kind="lib" path="lib/jshortcut-0.4-oberzalek.jar"/>
+	<classpathentry kind="lib" path="lib/netty-all-4.1.48.Final.jar"/>
+	<classpathentry kind="lib" path="lib/sqlite-jdbc-3.36.0.3.jar"/>
+	<classpathentry kind="lib" path="lib/commons-codec-1.15.jar"/>
+	<classpathentry kind="lib" path="lib/fastjson2-2.0.16.jar"/>
+	<classpathentry kind="lib" path="lib/iot-communication-1.4.4.jar"/>
+</classpath>

.editorconfig

@@ -0,0 +1,4 @@
+root = true
+
+[*]
+charset = utf-8

.gitignore

@@ -0,0 +1,7 @@
+.idea
+.settings
+classes
+bin
+out
+*.db
+*.iml

.project

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>MesOP200-sd</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+	<filteredResources>
+		<filter>
+			<id>1779072290228</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
+</projectDescription>

image/.gitignore

@@ -0,0 +1,2 @@
+META-INF
+_system~.ini

src/com/mes/component/CallFromJs.java

@@ -0,0 +1,10 @@
+package com.mes.component;
+
+import com.mes.ui.MesClient;
+
+public class CallFromJs {
+    public String callFromJs(String info){
+        System.out.print("ss:"+info);
+        return MesClient.sessionid+":java:" + info;
+    }
+}

src/com/mes/component/MesRadio.java

@@ -0,0 +1,57 @@
+package com.mes.component;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class MesRadio extends JPanel {
+
+    private String result = "";
+    private Integer i = 0;
+
+    public MesRadio(String[] radioTitles,String[] radioVals){
+        this.setLayout(new FlowLayout());
+        ButtonGroup group = new ButtonGroup();
+        i = 0;
+        for (String title:radioTitles){
+            JRadioButton radioButton = new JRadioButton(title);
+            radioButton.setFont(new Font("微软雅黑", Font.PLAIN, 28));
+
+            String val = radioVals[i];
+            radioButton.setName(val);
+
+            this.add(radioButton);
+            group.add(radioButton);
+
+            radioButton.addActionListener(new ActionListener() {
+                @Override
+                public void actionPerformed(ActionEvent e) {
+                    result = val;
+                    System.out.println("选择："+result);
+                }
+            });
+            i++;
+        }
+    }
+
+    public void setResult(String ret){
+        this.result = "";
+        Component[] components = this.getComponents();
+        for (Component jRadioButton:components){
+            if(jRadioButton instanceof JRadioButton){
+                JRadioButton jRadioButtonParam = (JRadioButton)jRadioButton;
+                if(ret.equals(jRadioButtonParam.getName())){
+                    jRadioButtonParam.setSelected(true);
+                    this.result = jRadioButtonParam.getName();
+                }else{
+                    jRadioButtonParam.setSelected(false);
+                }
+            }
+        }
+    }
+
+    public String getResult(){
+        return this.result;
+    }
+}

src/com/mes/component/MesWebView.java

@@ -0,0 +1,44 @@
+package com.mes.component;
+
+import javafx.application.Platform;
+import javafx.beans.value.ObservableValue;
+import javafx.concurrent.Worker;
+import javafx.embed.swing.JFXPanel;
+import javafx.scene.Scene;
+import javafx.scene.web.WebEngine;
+import javafx.scene.web.WebView;
+import netscape.javascript.JSObject;
+
+import java.util.Date;
+
+public class MesWebView extends JFXPanel {
+
+    public static WebEngine engine = null;
+
+    public MesWebView(String url){
+
+        Platform.runLater(() -> {
+            WebView webView = new WebView();
+            setScene(new Scene(webView));
+            Date date = new Date();
+//            String url = "http://"+mes_server_ip+":8980/js/a/mes/mesQuality/check?__sid="+sessionid+"&oprno="+mes_gw+"&t="+date.getTime();
+            System.out.print(url);
+            engine = webView.getEngine();
+            CallFromJs bridge = new CallFromJs();
+            engine.getLoadWorker().stateProperty().addListener(
+                    (ObservableValue<? extends Worker.State> ov, Worker.State oldState, Worker.State newState) -> {
+                        if (newState == Worker.State.SUCCEEDED) {
+                            JSObject window = (JSObject) engine.executeScript("window");
+                            window.setMember("apps", bridge);
+                            window.setMember("sout", System.out);
+                        }
+                    }
+            );
+            engine.load(url);
+        });
+    }
+
+    public void reloadWeb(){
+        engine.reload();
+    }
+}

src/com/mes/component/MyDialog.java

@@ -0,0 +1,30 @@
+package com.mes.component;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class MyDialog extends JDialog {
+
+    public MyDialog(Frame owner, String title, String msg){
+        super(owner, title);
+        init(msg);
+    }
+
+    private void init(String msg){
+        Container container = this.getContentPane();
+        container.setLayout(null);
+        container.setBackground(Color.BLACK);
+        this.setSize(800,220);
+        this.setLocationRelativeTo(null);
+
+        JLabel tslabel = new JLabel(msg);
+        tslabel.setHorizontalAlignment(SwingConstants.CENTER);
+        tslabel.setForeground(Color.RED);
+        tslabel.setFont(new Font("微软雅黑", Font.PLAIN,48));
+        tslabel.setBounds(0,30,800,100);
+
+        container.add(tslabel);
+        this.setModal(true);
+        this.setVisible(true);
+    }
+}

src/com/mes/netty/MesMsgUtils.java

@@ -0,0 +1,90 @@
+package com.mes.netty;
+
+public class MesMsgUtils {
+
+    public static int SYNR_LEN = 46;
+    public static int AXTW_LEN = 46;
+    public static int ACLW_LEN = 46;
+    public static int MCJW_LEN = 96;
+    public static int AQDW_LEN = 96;
+    public static int MBDW_LEN = 96;
+    public static int MJBW_LEN = 96;
+    public static int MQDW_LEN = 96;
+    public static int MKSW_LEN = 96;
+    public static int MSBW_LEN = 96;
+    public static int MCSW_LEN = 96;
+    public static int AQRW_LEN = 96;
+
+    public static String MSG_TYPE[] = {
+        "SYNR",
+        "AXTW",
+        "ACLW",
+        "MCJW",
+        "AQDW",
+        "MBDW",
+        "MJBW",
+        "MQDW",
+        "MKSW",
+        "MSBW",
+        "MCSW",
+        "AQRW",
+    };
+
+    public static int isMsgContentOK(String msg, String msg_type) {
+        //ret=0OK,1 空内容，2 长度不符
+        int ret = 0;
+        if(msg==null||msg.equalsIgnoreCase("")) {
+            ret = 1;
+            return ret;
+        }
+
+        int len = msg.length();
+        //System.out.println("len="+len);
+        switch(msg_type) {
+            case "SYNR":
+            case "AXTW":
+            case "ACLW":
+                if(len==SYNR_LEN) {
+                    ret = 0;
+                }else {
+                    ret = 2;
+                }
+                break;
+            default:
+                if(len==AQDW_LEN) {
+                    ret = 0;
+                }else {
+                    ret = 2;
+                }
+                break;
+        }
+        return ret;
+    }
+
+    // 判断报文类型是否在清单里
+    public static boolean isMsgTypeOk(String msg_type) {
+        for (String str : MSG_TYPE) {
+            if (str.equals(msg_type)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    // 处理报文数据
+    public static String processMsg(String msg, String msg_type) {
+        String processMsgRet = "";
+        if(msg_type.equalsIgnoreCase("SYNR")) {
+
+        }else if(msg_type.equalsIgnoreCase("AXTW")) {
+
+        }else if(msg_type.equalsIgnoreCase("ACLW")) {
+
+        }else{
+            processMsgRet = ProtocolParam.getResult(msg);
+        }
+        return processMsgRet;
+    }
+
+
+}

src/com/mes/netty/NettyClient.java

@@ -0,0 +1,63 @@
+package com.mes.netty;
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.handler.codec.string.StringEncoder;
+import java.util.concurrent.TimeUnit;
+
+import com.mes.ui.MesClient;
+
+public class NettyClient {
+    public SocketChannel socketChannel;
+    public static ChannelFuture future;
+
+    public  void run(Object msg){
+        //配置线程组
+        EventLoopGroup group = new NioEventLoopGroup();
+        //创建服务启动器
+        Bootstrap bootstrap = new Bootstrap();
+
+        //配置参数
+        bootstrap.group(group)
+                .channel(NioSocketChannel.class)
+                .option(ChannelOption.TCP_NODELAY,true)
+                .handler(new ChannelInitializer<SocketChannel>() {
+                    protected void initChannel(SocketChannel socketChannel) throws Exception {
+                        socketChannel.pipeline()
+                                .addLast(new XDecoder())
+                                .addLast(new StringEncoder())
+//                                    .addLast(new StringDecoder())
+                                .addLast(new NettyClientHandler());
+                    }
+                })
+                .remoteAddress(MesClient.mes_server_ip,MesClient.mes_tcp_port);
+
+        //连接
+        future = bootstrap.connect();
+        System.out.println("客户端正在连接服务端...");
+        //客户端断线重连逻辑
+        future.addListener((ChannelFutureListener) future1 -> {
+            if (future1.isSuccess()) {
+                //tcp连接成功
+                MesClient.tcp_connect_flag = true;
+                //设置TCP请求状态
+                MesClient.connect_request_flag = false;
+                System.out.println("连接Netty服务端成功");
+                future.channel().writeAndFlush(msg);
+            } else {
+                //tcp连接失败
+                MesClient.tcp_connect_flag = false;
+                MesClient.connect_request_flag = true;
+                System.out.println("连接失败，进行断线重连");
+                future1.channel().eventLoop().schedule(() -> run(msg), 10, TimeUnit.SECONDS);
+            }
+            //设置tcp连接状态
+            MesClient.setTcpStatus();
+        });
+        socketChannel = (SocketChannel) future.channel();
+
+    }
+}

src/com/mes/netty/NettyClientHandler.java

@@ -0,0 +1,82 @@
+package com.mes.netty;
+
+import com.mes.ui.MesClient;
+import com.mes.ui.MesRevice;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class NettyClientHandler extends ChannelInboundHandlerAdapter {
+
+    private final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+    public static byte[] responseByte;
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        System.out.println("mes connecting：" + sdf.format(new Date()));
+    }
+
+    @Override
+    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
+        Channel channel = ctx.channel();
+        System.err.println("close tcp, ip：" + channel.remoteAddress());
+        MesClient.tcp_connect_flag = false;
+        MesClient.setTcpStatus();
+        // 关闭通道
+        channel.close();
+    }
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        System.out.println("msg:"+msg);
+
+        String mes_msg = formatResult(msg.toString());
+        if(mes_msg == null || mes_msg.isEmpty()){ // error msg
+            return;
+        }
+
+        String msg_type = ProtocolParam.getMsgType(mes_msg);
+        System.out.println("msg_type="+msg_type);
+
+        String processMsgRet = MesMsgUtils.processMsg(mes_msg, msg_type);
+        System.out.println("processMsgRet="+processMsgRet);
+        switch(msg_type) {
+            case "AQDW": // 查询质量
+                MesRevice.checkQualityRevice(processMsgRet,mes_msg);
+                break;
+            case "MKSW":
+                MesRevice.startRevice(processMsgRet,mes_msg);
+                break;
+            case "MBDW":
+                MesRevice.bindRevice(processMsgRet,mes_msg);
+                break;
+            case "MJBW":
+                MesRevice.unbindRevice(processMsgRet,mes_msg);
+                break;
+            case "MQDW":
+                MesRevice.updateResultRevice(processMsgRet,mes_msg);
+                break;
+        }
+
+
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        ctx.close();
+    }
+
+    private String formatResult(String msg){
+        System.err.println("length：" + msg.length() + " content：" + msg);
+        String msgType = msg.substring(0,2).trim();
+        if(msgType.equals("OK")){
+            return msg.substring(3,msg.length());
+        }else{
+            return "";
+        }
+    }
+
+}

src/com/mes/netty/ProtocolParam.java

@@ -0,0 +1,73 @@
+package com.mes.netty;
+
+
+// 固定格式报文各参数获取方法
+public class ProtocolParam {
+    // bbbbfffffARWAQDWGWOP100 GY100000ID151245P00000106200123062900001      RSOKDA2023-09-07ZT10:16:58
+    public static Integer fixedLength = 96; // 固定长度
+
+    // 获取消息类型  所有报文都可使用
+    public static String getMsgType(String msg){
+        System.out.print(msg);
+        if(msg.length() < 16){
+            return "";
+        }
+        return msg.substring(12,16);
+    }
+
+    // 获取工位号
+    public static String getOprno(String msg){
+        if(msg.length() < 24){
+            return "";
+        }
+        return msg.substring(18,24);
+    }
+
+    // 获取工艺号
+    public static String getCraft(String msg){
+        if(msg.length() < 32){
+            return "";
+        }
+        return msg.substring(26,32);
+    }
+
+    // 获取镭雕码或设备报警故障代码
+    public static String getSn(String msg){
+        if(msg.length() < 70){
+            return "";
+        }
+        return msg.substring(34,70);
+    }
+
+    public static String getLx(String msg){
+        if(msg.length() < 72){
+            return "";
+        }
+        return msg.substring(70,72);
+    }
+
+    // 获取结果
+    public static String getResult(String msg){
+        if(msg.length() < 74){
+            return "";
+        }
+        return msg.substring(72,74);
+    }
+
+    // 获取日期
+    public static String getDay(String msg){
+        if(msg.length() < 86){
+            return "";
+        }
+        return msg.substring(76,86);
+    }
+
+    // 获取时间
+    public static String getTime(String msg){
+        if(msg.length() < 96){
+            return "";
+        }
+        return msg.substring(88,96);
+    }
+
+}

src/com/mes/netty/XDecoder.java

@@ -0,0 +1,168 @@
+package com.mes.netty;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufUtil;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+
+import java.util.List;
+
+public class XDecoder extends ByteToMessageDecoder {
+    static final int PACKET_SIZE = 46; // 最短包长度
+    static final int PACKET_MAX_SIZE = 1000; // 最长包长度
+
+    // 用来临时保留没有处理过的请求报文
+    ByteBuf tempMsg = Unpooled.buffer();
+
+    /**
+     * @param ctx
+     * @param in 请求的数据
+     * @param out 将粘在一起的报文拆分后的结果保留起来
+     * @throws Exception
+     */
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
+        System.out.println(Thread.currentThread() + "收到了一次数据包，长度是：" + in.readableBytes());
+        String content = hexStringToAscii(ByteBufUtil.hexDump(in));
+        System.out.println("接收包内容：" + hexStringToAscii(ByteBufUtil.hexDump(in)));
+
+        // 合并报文
+        ByteBuf message = null;
+        int tmpMsgSize = tempMsg.readableBytes();
+        // 如果暂存有上一次余下的请求报文，则合并
+        if (tmpMsgSize > 0) {
+            message = Unpooled.buffer();
+            message.writeBytes(tempMsg);
+            message.writeBytes(in);
+            System.out.println("合并：上一数据包余下的长度为：" + tmpMsgSize + ",合并后长度为:" + message.readableBytes());
+            System.out.println("合并后包内容：" + hexStringToAscii(ByteBufUtil.hexDump(message)));
+        } else {
+            message = in;
+        }
+
+//        System.out.println(Thread.currentThread() + "收到了一次数据包，长度是：" + message.readableBytes());
+        int size = 0;
+        String split = "bbbbfffffARW";
+
+        while (true){
+            size = message.readableBytes();
+            if(size >= PACKET_SIZE){
+                String retType = "NG:";
+                int qcsize = 0;
+                String str = hexStringToAscii(ByteBufUtil.hexDump(message));
+                String[] lists = str.split(split);
+
+                if(lists.length == 1 && size > PACKET_MAX_SIZE){ // 大于最大包长度
+                    byte[] request = new byte[size - PACKET_MAX_SIZE];
+                    // 每次从总的消息中读取n个字节的数据
+                    message.readBytes(request);
+                    // 将拆分后的结果放入out列表中，交由后面的业务逻辑去处理
+                    out.add(retType+hexStringToAscii(ByteBufUtil.hexDump(Unpooled.copiedBuffer(request))));
+                    break;
+                }
+
+                if(lists[0].length() > 0){
+                    byte[] request = new byte[lists[0].length()];
+                    // 每次从总的消息中读取n个字节的数据
+                    message.readBytes(request);
+                    // 将拆分后的结果放入out列表中，交由后面的业务逻辑去处理
+                    out.add(retType+hexStringToAscii(ByteBufUtil.hexDump(Unpooled.copiedBuffer(request))));
+                }else{
+                    if(lists.length > 1){
+                        String ss = lists[1];
+                        if(ss.length() <= 4){
+                            qcsize += ss.length();
+                        }else{
+                            String msgType = ProtocolParam.getMsgType(split+ss);
+                            if(!MesMsgUtils.isMsgTypeOk(msgType)){
+                                qcsize += split.length() + ss.length();
+                            }else{
+                                Integer ppsize = checkResultSize(ss,msgType,split);
+                                if(ppsize > 0){
+                                    qcsize = ppsize;
+                                    retType = "OK:";
+                                }else{
+                                    qcsize += split.length() + ss.length();
+                                }
+                            }
+                        }
+                    }
+                }
+
+
+                if(qcsize > 0){
+                    byte[] request = new byte[qcsize];
+                    // 每次从总的消息中读取n个字节的数据
+                    message.readBytes(request);
+                    // 将拆分后的结果放入out列表中，交由后面的业务逻辑去处理
+                    out.add(retType+hexStringToAscii(ByteBufUtil.hexDump(Unpooled.copiedBuffer(request))));
+                }
+            }else{
+                break;
+            }
+        }
+
+        // 多余的报文存起来
+        // 第一个报文： i+  暂存
+        // 第二个报文： 1 与第一次
+        size = message.readableBytes();
+        if (size != 0) {
+            System.out.println("多余的数据长度：" + size);
+            // 剩下来的数据放到tempMsg暂存
+            tempMsg.clear();
+            tempMsg.writeBytes(message.readBytes(size));
+        }
+    }
+
+    private Integer checkResultSize(String str, String msg_type, String split){
+        String oldstr = str;
+        str = split+str;
+        int tpsize = 0;
+        switch(msg_type) {
+            case "SYNR": // 同步
+                if(str.length() >= MesMsgUtils.SYNR_LEN){
+                    tpsize = MesMsgUtils.SYNR_LEN;
+                }
+                break;
+            case "AXTW": // 心跳
+                if(str.length() >= MesMsgUtils.AXTW_LEN){
+                    tpsize = MesMsgUtils.AXTW_LEN;
+                }
+                break;
+            case "ACLW": // 重连
+                if(str.length() >= MesMsgUtils.ACLW_LEN){
+                    tpsize = MesMsgUtils.ACLW_LEN;
+                }
+                break;
+            case "MCJW":
+            case "AQDW":
+            case "MBDW":
+            case "MJBW":
+            case "MQDW":
+            case "MKSW":
+            case "MSBW":
+            case "MCSW":
+            case "AQRW":
+            default: // 默认新报文
+                if(str.length() >= ProtocolParam.fixedLength){ // 大于固定长度
+                    tpsize = ProtocolParam.fixedLength;
+                }
+                break;
+        }
+
+        return tpsize;
+    }
+
+    // 16字符串转Ascii
+    private String hexStringToAscii(String hexString) {
+        StringBuilder sbuilder = new StringBuilder();
+        for (int i = 0; i < hexString.length(); i += 2) {
+            String hexByte = hexString.substring(i, i + 2);
+            int byteValue = Integer.parseInt(hexByte, 16);
+            char c = (char) byteValue;
+            sbuilder.append(c);
+        }
+        return sbuilder.toString();
+    }
+}

src/com/mes/ui/BindMaterialResp.java

@@ -0,0 +1,58 @@
+package com.mes.ui;
+
+public class BindMaterialResp {
+    private String materialId;
+    private String materialTitle;
+    private String craft;
+    private String batchSn;
+    private String lastTimes;
+    private String type;
+
+    public String getMaterialId() {
+        return materialId;
+    }
+
+    public void setMaterialId(String materialId) {
+        this.materialId = materialId;
+    }
+
+    public String getMaterialTitle() {
+        return materialTitle;
+    }
+
+    public void setMaterialTitle(String materialTitle) {
+        this.materialTitle = materialTitle;
+    }
+
+    public String getCraft() {
+        return craft;
+    }
+
+    public void setCraft(String craft) {
+        this.craft = craft;
+    }
+
+    public String getBatchSn() {
+        return batchSn;
+    }
+
+    public void setBatchSn(String batchSn) {
+        this.batchSn = batchSn;
+    }
+
+    public String getLastTimes() {
+        return lastTimes;
+    }
+
+    public void setLastTimes(String lastTimes) {
+        this.lastTimes = lastTimes;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+}

src/com/mes/ui/DataUtil.java

@@ -0,0 +1,338 @@
+package com.mes.ui;
+
+import com.alibaba.fastjson2.JSONObject;
+import com.mes.netty.NettyClient;
+import com.mes.util.DateLocalUtils;
+import com.mes.util.JdbcUtils;
+
+import java.io.*;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Properties;
+
+public class DataUtil {
+
+    // 删除当前工位后台工件码
+    public static JSONObject delCurSn(String oprno, String serverIp, String lineSn) {
+        try {
+            String url = "http://" + serverIp + ":8980/js/a/mes/mesProductRecord/cancelCurSn";
+            String params = "__ajax=json&oprno=" + oprno + "&lineSn=" + lineSn + "&__sid=" + MesClient.sessionid;
+            String result = doPost(url, params);
+            if (result == null || result.equalsIgnoreCase("false")) {
+                return null;
+            }
+            return JSONObject.parseObject(result);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    // 从后台获取当前工位工件码
+    public static JSONObject getCurSn(String oprno, String serverIp, String lineSn) {
+        try {
+            String url = "http://" + serverIp + ":8980/js/a/mes/mesProductRecord/getCurSn";
+            String params = "__ajax=json&oprno=" + oprno + "&lineSn=" + lineSn + "&__sid=" + MesClient.sessionid;
+            String result = doPost(url, params);
+            if (result == null || result.equalsIgnoreCase("false")) {
+                return null;
+            }
+            return JSONObject.parseObject(result);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static Boolean synrTcp(NettyClient nettyClient,String mes_gw){
+        try{
+            //TCP连接后，直接先发同步报文
+            String start = "aaaabbbbbABW";
+            String msgType = "SYNR";
+            String gw = "GW"+DataUtil.rightPad(mes_gw, 6);
+            String da = "DA" + DateLocalUtils.getCurrentDate();
+            String zt = "ZT" + DateLocalUtils.getCurrentTimeHMS();
+            String synr_str = start + msgType + gw + da + zt;
+            //插入报文本地数据
+            String gy = "";
+            String sn = "";
+            JdbcUtils.insertData(gw, gy, synr_str, msgType, sn);
+
+            nettyClient.run(synr_str);
+
+            return true;
+        }catch (Exception e){
+            return false;
+        }
+    }
+
+    public static Boolean heartBeat(NettyClient nettyClient,String mes_gw){
+        try{
+            //TCP连接后，直接先发同步报文
+            String start = "aaaabbbbbABW";
+            String msgType = "AXTW";
+            String gw = "GW"+DataUtil.rightPad(mes_gw, 6);
+            String da = "DA" + DateLocalUtils.getCurrentDate();
+            String zt = "ZT" + DateLocalUtils.getCurrentTimeHMS();
+            String axtw_str = start + msgType + gw + da + zt;
+            //插入报文本地数据
+            String gy = "";
+            String sn = "";
+            JdbcUtils.insertData(gw, gy, axtw_str, msgType, sn);
+            nettyClient.future.channel().writeAndFlush(axtw_str);
+
+            return true;
+        }catch (Exception e){
+            return false;
+        }
+    }
+
+    public static JSONObject checkQuality(String sn, String user) {
+        try {
+            String url = "http://" + MesClient.mes_server_ip + ":8980/js/a/mes/mesProductRecord/pccheck";
+            String params = "__ajax=json&oprno=" + MesClient.mes_gw.trim()
+                    + "&lineSn=" + MesClient.mes_line_sn.trim()
+                    + "&sn=" + sn.trim()
+                    + "&ucode=" + user.trim()
+                    + "&__sid=" + MesClient.sessionid;
+            System.out.println("pccheck params=" + params);
+            String result = doPost(url, params);
+            System.out.println("pccheck result=" + result);
+            if (result == null || result.equalsIgnoreCase("false")) {
+                return null;
+            }
+            JdbcUtils.insertData(MesClient.mes_gw, "100000", params, "AQDW", sn.trim());
+            return JSONObject.parseObject(result);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static JSONObject sendQuality(String sn, String ret, String user) {
+        try {
+            String url = "http://" + MesClient.mes_server_ip + ":8980/js/a/mes/mesProductRecord/pcresult";
+            String params = "__ajax=json&oprno=" + MesClient.mes_gw.trim()
+                    + "&lineSn=" + MesClient.mes_line_sn.trim()
+                    + "&sn=" + sn.trim()
+                    + "&result=" + ret.trim()
+                    + "&ucode=" + user.trim()
+                    + "&__sid=" + MesClient.sessionid;
+            System.out.println("pcresult params=" + params);
+            String result = doPost(url, params);
+            System.out.println("pcresult result=" + result);
+            if (result == null || result.equalsIgnoreCase("false")) {
+                return null;
+            }
+            JdbcUtils.insertData(MesClient.mes_gw, "100000", params, "MQDW", sn.trim());
+            return JSONObject.parseObject(result);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static Boolean bindUser(NettyClient nettyClient,String sn,String user){
+        try{
+            String msgType = "MBDW";
+            String gy = "400001";
+            String param = rightPad(user, 36);
+            Boolean aqdw_str = sendMessage(nettyClient,msgType,gy,"",sn,"",user,"01",param);
+            return aqdw_str;
+        }catch (Exception e){
+            return false;
+        }
+    }
+
+    public static Boolean bindWarehouse(NettyClient nettyClient,String sn,String wsn,String user,String craft){
+        try{
+            String msgType = "MBDW";
+            String param = rightPad(wsn, 36);
+            Boolean aqdw_str = sendMessage(nettyClient,msgType,craft,"",sn,"",user,"01",param);
+            return aqdw_str;
+        }catch (Exception e){
+            return false;
+        }
+    }
+
+    public static Boolean unBindWarehouse(NettyClient nettyClient,String sn,String wsn,String user,String craft){
+        try{
+            String msgType = "MJBW";
+            String param = rightPad(wsn, 36);
+            Boolean aqdw_str = sendMessage(nettyClient,msgType,craft,"",sn,"",user,"01",param);
+            return aqdw_str;
+        }catch (Exception e){
+            return false;
+        }
+    }
+
+    public static Boolean sendMessage(NettyClient nettyClient,String msgType,String craft,String lx,String sn,String result,String user,String paramNums,String params){
+        try{
+            String enconding = "UTF-8";
+            InputStream is = ClassLoader.getSystemResourceAsStream("config/config.properties");
+            Properties pro = new Properties();
+            BufferedReader br = new BufferedReader(new InputStreamReader(is, enconding));
+            pro.load(br);
+            String gw = "GW"+rightPad(pro.getProperty("mes.gw"), 6);
+            String start = "aaaabbbbbABW";
+            String gy = "GY" + rightPad(craft, 6);
+            String reslx = "LX" + rightPad(lx, 2);
+            String id = pro.getProperty("mes.line_sn") + rightPad(sn, 36);
+            String rs = "RS"+ rightPad(result, 2);
+            String da = "DA" + DateLocalUtils.getCurrentDate();
+            String zt = "ZT" + DateLocalUtils.getCurrentTimeHMS();
+            String yh = "YH" + rightPad(user, 20);
+            String aqdw_str = start + msgType + gw + gy + reslx + id + rs + da + zt + yh + paramNums + params;
+            System.out.println("message="+aqdw_str);
+            JdbcUtils.insertData(gw, gy, aqdw_str, msgType, sn);
+            nettyClient.future.channel().writeAndFlush(aqdw_str);
+            return true;
+        }catch (Exception e){
+            return false;
+        }
+    }
+
+    public static String rightPad(final String str, final int size) {
+        if (str == null) {
+            return null;
+        }
+
+        String strret = str;
+        if(str.length() > size){
+            strret = str.substring(0,size);
+        }
+        return String.format("%-"+size+"s", strret);
+    }
+
+    public static JSONObject getBindMaterail() {
+        try{
+            String enconding = "UTF-8";
+            InputStream is = ClassLoader.getSystemResourceAsStream("config/config.properties");
+            Properties pro = new Properties();
+            BufferedReader br = new BufferedReader(new InputStreamReader(is, enconding));
+            pro.load(br);
+            String mes_server_ip = pro.getProperty("mes.server_ip");
+            String oprno = pro.getProperty("mes.gw").trim();
+            String lineSn = pro.getProperty("mes.line_sn").trim();
+            String url = "http://"+mes_server_ip+":8980/js/a/mes/mesLineProcessMaterial/materials";
+            String params = "__ajax=json&oprno="+oprno+"&lineSn="+lineSn;
+            System.out.println("params="+params);
+            String result = doPost(url,params);
+            System.out.println("result="+result);
+
+            if(result.equalsIgnoreCase("false")) {
+                return null;
+            }else {
+                return JSONObject.parseObject(result);
+            }
+        }catch (Exception e){
+            return null;
+        }
+    }
+
+    public static JSONObject saveBindMaterail(String batchSn,String craft,String materialId,String type) {
+        try{
+            String enconding = "UTF-8";
+            InputStream is = ClassLoader.getSystemResourceAsStream("config/config.properties");
+            Properties pro = new Properties();
+            BufferedReader br = new BufferedReader(new InputStreamReader(is, enconding));
+            pro.load(br);
+            String mes_server_ip = pro.getProperty("mes.server_ip");
+            String oprno = pro.getProperty("mes.gw").trim();
+            String lineSn = pro.getProperty("mes.line_sn").trim();
+            String url = "http://"+mes_server_ip+":8980/js/a/mes/mesMaterialPrebind/bind";
+            String params = "__ajax=json&oprno="+oprno+"&lineSn="+lineSn+"&batchSn="+batchSn+"&craft="+craft+"&materialId="+materialId+"&type="+type;
+            System.out.println("params="+params);
+            String result = doPost(url,params);
+            System.out.println("result="+result);
+
+            if(result.equalsIgnoreCase("false")) {
+                return null;
+            }else {
+                return JSONObject.parseObject(result);
+            }
+        }catch (Exception e){
+            return null;
+        }
+    }
+
+    public static JSONObject upParams(String upparams) {
+        try{
+            String mes_server_ip = MesClient.mes_server_ip;
+            String url = "http://"+mes_server_ip+":8980/js/a/mes/mesProductProd/batchsave";
+            String params = "__ajax=json&oprno="+MesClient.mes_gw+"&lineSn="+MesClient.mes_line_sn+"&params="+upparams;
+            System.out.println("params="+params);
+            String result = doPost(url,params);
+            System.out.println("result="+result);
+
+            if(result.equalsIgnoreCase("false")) {
+                return null;
+            }else {
+                return JSONObject.parseObject(result);
+            }
+        }catch (Exception e){
+            return null;
+        }
+    }
+
+    public static String doPost(String httpUrl, String param) {
+        HttpURLConnection connection = null;
+        InputStream is = null;
+        OutputStream os = null;
+        BufferedReader br = null;
+        String result = null;
+        try {
+            URL url = new URL(httpUrl);
+            connection = (HttpURLConnection) url.openConnection();
+            connection.setRequestMethod("POST");
+            connection.setConnectTimeout(15000);
+            connection.setReadTimeout(60000);
+            connection.setDoOutput(true);
+            connection.setDoInput(true);
+            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
+            connection.setRequestProperty("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
+            os = connection.getOutputStream();
+            os.write(param.getBytes("UTF-8"));
+            if (connection.getResponseCode() == 200) {
+                is = connection.getInputStream();
+                br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
+                StringBuffer sbf = new StringBuffer();
+                String temp = null;
+                while ((temp = br.readLine()) != null) {
+                    sbf.append(temp);
+                    sbf.append("\r\n");
+                }
+                result = sbf.toString();
+            }
+        } catch (MalformedURLException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (null != br) {
+                try {
+                    br.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            if (null != os) {
+                try {
+                    os.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            if (null != is) {
+                try {
+                    is.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            connection.disconnect();
+        }
+        return result;
+    }
+}

src/com/mes/ui/DeviceManagePanel.java

@@ -0,0 +1,336 @@
+package com.mes.ui;
+
+import com.github.xingshuangs.iot.protocol.modbus.service.ModbusTcp;
+import com.mes.util.JdbcUtils;
+
+import javax.swing.*;
+import javax.swing.table.DefaultTableModel;
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 设备管理：IP、预设数量、按颗数区间的铆接参数配置
+ */
+public class DeviceManagePanel extends JPanel {
+
+    private static final String[] PARAM_COLUMNS = {"起始颗", "结束颗", "F-min", "F-max", "S-min", "S-max"};
+    private static final int CONTENT_WIDTH = 940;
+
+    private JTextField txtASet;
+    private JTextField txtBSet;
+    private JTextField txtIpA;
+    private JTextField txtIpB;
+    private DefaultTableModel tableModelA;
+    private DefaultTableModel tableModelB;
+    private JTable tableA;
+    private JTable tableB;
+
+    public DeviceManagePanel() {
+        setLayout(null);
+        setPreferredSize(new Dimension(980, 720));
+        buildUi();
+        loadConfigToUi();
+    }
+
+    private void buildUi() {
+        Font labelFont = new Font("微软雅黑", Font.PLAIN, 18);
+        Font fieldFont = new Font("微软雅黑", Font.PLAIN, 18);
+        Font hintFont = new Font("微软雅黑", Font.PLAIN, 14);
+
+        addLabel("A枪预设数量：", 20, 16, 130, 34, labelFont);
+        txtASet = addField(String.valueOf(MesClient.aSetNum), 150, 16, 120, 34, fieldFont);
+
+        addLabel("B枪预设数量：", 320, 16, 130, 34, labelFont);
+        txtBSet = addField(String.valueOf(MesClient.bSetNum), 450, 16, 120, 34, fieldFont);
+
+        addLabel("A枪IP：", 20, 58, 80, 34, labelFont);
+        txtIpA = addField(MesClient.curIpA, 100, 58, 170, 34, fieldFont);
+
+        addLabel("B枪IP：", 320, 58, 80, 34, labelFont);
+        txtIpB = addField(MesClient.curIpB, 400, 58, 170, 34, fieldFont);
+
+        addLabel("说明：S-min/S-max 为PLC原始值，界面行程显示值 = S / 1000", 20, 98, CONTENT_WIDTH, 24, hintFont);
+
+        addLabel("A枪参数区间", 20, 128, 200, 28, labelFont);
+        tableModelA = createParamTableModel();
+        tableA = createParamTable(tableModelA, 20, 156, CONTENT_WIDTH, 150);
+
+        JButton btnAddA = new JButton("A枪添加行");
+        btnAddA.setFont(labelFont);
+        btnAddA.setBounds(20, 316, 120, 32);
+        btnAddA.addActionListener(e -> tableModelA.addRow(new Object[]{"", "", "0", "0", "0", "0"}));
+        add(btnAddA);
+
+        JButton btnDelA = new JButton("A枪删除行");
+        btnDelA.setFont(labelFont);
+        btnDelA.setBounds(150, 316, 120, 32);
+        btnDelA.addActionListener(e -> removeSelectedRow(tableA, tableModelA));
+        add(btnDelA);
+
+        addLabel("B枪参数区间", 20, 360, 200, 28, labelFont);
+        tableModelB = createParamTableModel();
+        tableB = createParamTable(tableModelB, 20, 388, CONTENT_WIDTH, 150);
+
+        JButton btnAddB = new JButton("B枪添加行");
+        btnAddB.setFont(labelFont);
+        btnAddB.setBounds(20, 548, 120, 32);
+        btnAddB.addActionListener(e -> tableModelB.addRow(new Object[]{"", "", "0", "0", "0", "0"}));
+        add(btnAddB);
+
+        JButton btnDelB = new JButton("B枪删除行");
+        btnDelB.setFont(labelFont);
+        btnDelB.setBounds(150, 548, 120, 32);
+        btnDelB.addActionListener(e -> removeSelectedRow(tableB, tableModelB));
+        add(btnDelB);
+
+        JButton btnSave = new JButton("保存全部设置");
+        btnSave.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        btnSave.setBounds(380, 596, 180, 45);
+        btnSave.addActionListener(e -> saveAllConfig());
+        add(btnSave);
+
+        addLabel("每行表示「从起始颗到结束颗」使用同一套参数；开工时下发第1颗参数，每完成一颗后自动切换下一颗区间。",
+                20, 652, CONTENT_WIDTH, 40, hintFont);
+    }
+
+    private void addLabel(String text, int x, int y, int w, int h, Font font) {
+        JLabel label = new JLabel("<html>" + text + "</html>");
+        label.setFont(font);
+        label.setBounds(x, y, w, h);
+        add(label);
+    }
+
+    private JTextField addField(String text, int x, int y, int w, int h, Font font) {
+        JTextField field = new JTextField(text);
+        field.setFont(font);
+        field.setBounds(x, y, w, h);
+        add(field);
+        return field;
+    }
+
+    private DefaultTableModel createParamTableModel() {
+        return new DefaultTableModel(PARAM_COLUMNS, 0) {
+            @Override
+            public boolean isCellEditable(int row, int column) {
+                return true;
+            }
+        };
+    }
+
+    private JTable createParamTable(DefaultTableModel model, int x, int y, int w, int h) {
+        JTable table = new JTable(model);
+        table.setRowHeight(28);
+        table.setFont(new Font("微软雅黑", Font.PLAIN, 14));
+        table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
+        JScrollPane scrollPane = new JScrollPane(table);
+        scrollPane.setBounds(x, y, w, h);
+        add(scrollPane);
+        return table;
+    }
+
+    private void removeSelectedRow(JTable table, DefaultTableModel model) {
+        int row = table.getSelectedRow();
+        if (row >= 0) {
+            model.removeRow(row);
+        }
+    }
+
+    private void loadConfigToUi() {
+        txtASet.setText(String.valueOf(MesClient.aSetNum));
+        txtBSet.setText(String.valueOf(MesClient.bSetNum));
+        txtIpA.setText(MesClient.curIpA);
+        txtIpB.setText(MesClient.curIpB);
+        fillTableModel(tableModelA, JdbcUtils.getRivetParams("A"));
+        fillTableModel(tableModelB, JdbcUtils.getRivetParams("B"));
+    }
+
+    // 重新从数据库加载到界面（进入设备管理页时调用）
+    public void reloadFromDb() {
+        Map<String, Object> config = JdbcUtils.getConfig();
+        if (config.size() > 0) {
+            MesClient.aSetNum = (Short) config.get("a_set_num");
+            MesClient.bSetNum = (Short) config.get("b_set_num");
+            MesClient.curIpA = (String) config.get("plc_ip_a");
+            MesClient.curIpB = (String) config.get("plc_ip_b");
+        }
+        MesClient.loadRivetParamConfig();
+        loadConfigToUi();
+    }
+
+    private void fillTableModel(DefaultTableModel model, List<RivetParamRange> ranges) {
+        model.setRowCount(0);
+        for (RivetParamRange range : ranges) {
+            model.addRow(new Object[]{
+                    String.valueOf(range.getStartRivet()),
+                    String.valueOf(range.getEndRivet()),
+                    String.valueOf(range.getFMin()),
+                    String.valueOf(range.getFMax()),
+                    String.valueOf(range.getSMin()),
+                    String.valueOf(range.getSMax())
+            });
+        }
+    }
+
+    private List<RivetParamRange> parseTableModel(DefaultTableModel model, String gunType) throws IllegalArgumentException {
+        List<RivetParamRange> ranges = new ArrayList<>();
+        for (int i = 0; i < model.getRowCount(); i++) {
+            String startText = String.valueOf(model.getValueAt(i, 0)).trim();
+            String endText = String.valueOf(model.getValueAt(i, 1)).trim();
+            if (startText.isEmpty() && endText.isEmpty()) {
+                continue;
+            }
+            if (startText.isEmpty() || endText.isEmpty()) {
+                throw new IllegalArgumentException(gunType + "枪第" + (i + 1) + "行起始颗/结束颗不能为空");
+            }
+            int start = Integer.parseInt(startText);
+            int end = Integer.parseInt(endText);
+            if (start < 1 || end < start) {
+                throw new IllegalArgumentException(gunType + "枪第" + (i + 1) + "行颗数范围无效");
+            }
+            int fMin = parseIntCell(model, i, 2);
+            int fMax = parseIntCell(model, i, 3);
+            int sMin = parseIntCell(model, i, 4);
+            int sMax = parseIntCell(model, i, 5);
+            if (fMin > fMax) {
+                throw new IllegalArgumentException(gunType + "枪第" + (i + 1) + "行 F-min 不能大于 F-max");
+            }
+            if (sMin > sMax) {
+                throw new IllegalArgumentException(gunType + "枪第" + (i + 1) + "行 S-min 不能大于 S-max");
+            }
+            // PLC Int16 写入上限，避免溢出后下发错误值
+            if (fMin < Short.MIN_VALUE || fMax > Short.MAX_VALUE
+                    || sMin < Short.MIN_VALUE || sMax > Short.MAX_VALUE) {
+                throw new IllegalArgumentException(gunType + "枪第" + (i + 1) + "行参数超出范围(-32768~32767)");
+            }
+            RivetParamRange range = new RivetParamRange();
+            range.setGunType(gunType);
+            range.setStartRivet(start);
+            range.setEndRivet(end);
+            range.setFMin(fMin);
+            range.setFMax(fMax);
+            range.setSMin(sMin);
+            range.setSMax(sMax);
+            ranges.add(range);
+        }
+        if (ranges.isEmpty()) {
+            throw new IllegalArgumentException(gunType + "枪至少配置一行参数区间");
+        }
+        // 检查区间是否重叠，重叠会导致下发时命中错误行
+        for (int i = 0; i < ranges.size(); i++) {
+            RivetParamRange a = ranges.get(i);
+            for (int j = i + 1; j < ranges.size(); j++) {
+                RivetParamRange b = ranges.get(j);
+                if (a.getStartRivet() <= b.getEndRivet() && b.getStartRivet() <= a.getEndRivet()) {
+                    throw new IllegalArgumentException(gunType + "枪参数区间存在重叠："
+                            + a.getStartRivet() + "-" + a.getEndRivet()
+                            + " 与 " + b.getStartRivet() + "-" + b.getEndRivet());
+                }
+            }
+        }
+        return ranges;
+    }
+
+    private int parseIntCell(DefaultTableModel model, int row, int col) {
+        String text = String.valueOf(model.getValueAt(row, col)).trim();
+        if (text.isEmpty()) {
+            return 0;
+        }
+        return Integer.parseInt(text);
+    }
+
+    // 提交表格编辑并将参数下发到PLC
+    private boolean pushRivetParamsToDevice(ModbusTcp plc, List<RivetParamRange> ranges, String gunType) {
+        if (plc == null) {
+            System.out.println(gunType + "枪PLC未连接，跳过参数下发");
+            return false;
+        }
+        try {
+            ModbusUtil.syncRivetParamsToPlc(plc, ranges);
+            return true;
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            return false;
+        }
+    }
+
+    private void saveAllConfig() {
+        // 保存前先结束表格编辑，确保最新输入写入模型
+        if (tableA != null && tableA.isEditing()) {
+            tableA.getCellEditor().stopCellEditing();
+        }
+        if (tableB != null && tableB.isEditing()) {
+            tableB.getCellEditor().stopCellEditing();
+        }
+        try {
+            short newASet = Short.parseShort(txtASet.getText().trim());
+            short newBSet = Short.parseShort(txtBSet.getText().trim());
+            String newIpA = txtIpA.getText().trim();
+            String newIpB = txtIpB.getText().trim();
+            if (newIpA.isEmpty() || newIpB.isEmpty()) {
+                JOptionPane.showMessageDialog(MesClient.mesClientFrame, "IP地址不能为空", "错误", JOptionPane.ERROR_MESSAGE);
+                return;
+            }
+
+            List<RivetParamRange> rangesA = parseTableModel(tableModelA, "A");
+            List<RivetParamRange> rangesB = parseTableModel(tableModelB, "B");
+
+            boolean configOk = JdbcUtils.updateConfig(newASet, newBSet, newIpA, newIpB);
+            boolean saveAOk = JdbcUtils.saveRivetParams("A", rangesA);
+            boolean saveBOk = JdbcUtils.saveRivetParams("B", rangesB);
+            if (!configOk || !saveAOk || !saveBOk) {
+                JOptionPane.showMessageDialog(MesClient.mesClientFrame,
+                        "配置保存失败，请查看控制台日志后重试（常见原因：数据库被占用）",
+                        "错误", JOptionPane.ERROR_MESSAGE);
+                // 回读数据库，避免界面显示未真正落库的值
+                reloadFromDb();
+                return;
+            }
+
+            MesClient.aSetNum = newASet;
+            MesClient.bSetNum = newBSet;
+            MesClient.rivetParamRangesA = rangesA;
+            MesClient.rivetParamRangesB = rangesB;
+
+            if (MesClient.param1 != null) {
+                MesClient.param1.setText(String.valueOf(MesClient.aSetNum));
+            }
+            if (MesClient.param3 != null) {
+                MesClient.param3.setText(String.valueOf(MesClient.bSetNum));
+            }
+
+            boolean ipAChanged = !newIpA.equals(MesClient.curIpA);
+            boolean ipBChanged = !newIpB.equals(MesClient.curIpB);
+            if (ipAChanged) {
+                if (MesClient.plcA != null) {
+                    MesClient.plcA.close();
+                }
+                MesClient.curIpA = newIpA;
+                MesClient.plcA = new ModbusTcp(1, MesClient.curIpA);
+            }
+            if (ipBChanged) {
+                if (MesClient.plcB != null) {
+                    MesClient.plcB.close();
+                }
+                MesClient.curIpB = newIpB;
+                MesClient.plcB = new ModbusTcp(1, MesClient.curIpB);
+            }
+
+            // 保存后立即将拉力/行程参数下发到设备
+            boolean syncA = pushRivetParamsToDevice(MesClient.plcA, rangesA, "A");
+            boolean syncB = pushRivetParamsToDevice(MesClient.plcB, rangesB, "B");
+            if (syncA && syncB) {
+                JOptionPane.showMessageDialog(MesClient.mesClientFrame, "配置已保存，并已下发到设备", "提示", JOptionPane.INFORMATION_MESSAGE);
+            } else {
+                JOptionPane.showMessageDialog(MesClient.mesClientFrame,
+                        "配置已保存到本地，但部分设备参数下发失败，请检查设备连接；下次开工时会按新配置重新下发",
+                        "提示", JOptionPane.WARNING_MESSAGE);
+            }
+        } catch (NumberFormatException ex) {
+            JOptionPane.showMessageDialog(MesClient.mesClientFrame, "请输入有效的数字", "错误", JOptionPane.ERROR_MESSAGE);
+        } catch (IllegalArgumentException ex) {
+            JOptionPane.showMessageDialog(MesClient.mesClientFrame, ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
+        }
+    }
+}

src/com/mes/ui/ErrorMsg.java

@@ -0,0 +1,53 @@
+package com.mes.ui;
+
+import com.mes.netty.MesMsgUtils;
+import com.mes.netty.ProtocolParam;
+
+public class ErrorMsg {
+    public static void setErrorMsg(String mes_msg){
+        try{
+            String msg_type = ProtocolParam.getMsgType(mes_msg);
+            String processMsgRet = MesMsgUtils.processMsg(mes_msg, msg_type);
+            String lmsg = "该工件本工位不可加工";
+            if(processMsgRet.equalsIgnoreCase("OK")||processMsgRet.equalsIgnoreCase("NG")) {
+                lmsg = "该工件本工位已加工，结果："+processMsgRet;
+            }else if(processMsgRet.equalsIgnoreCase("NE")) {
+                lmsg = "该工件未录入系统";
+            }else if(processMsgRet.equalsIgnoreCase("NN")) {
+                lmsg = "该工件跳过该工位";
+            }else if(processMsgRet.equalsIgnoreCase("QN")) {
+                lmsg = "该工件OP"+ ProtocolParam.getLx(mes_msg)+"0加工NG";
+            }else if(processMsgRet.equalsIgnoreCase("QD")) {
+                lmsg = "该工件OP"+ ProtocolParam.getLx(mes_msg)+"0未加工";
+            }else if(processMsgRet.equalsIgnoreCase("NF")) {
+                lmsg = "该工件已合格下线";
+            }else if(processMsgRet.equalsIgnoreCase("NR")) {
+                lmsg = "该工件离线返修中";
+            }else if(processMsgRet.equalsIgnoreCase("NB")) {
+                lmsg = "该工件已报废";
+            }else if(processMsgRet.equalsIgnoreCase("ND")) {
+                lmsg = "该工件NG待处理";
+            }else if(processMsgRet.equalsIgnoreCase("FN")) {
+                lmsg = "首件检查工件不合格停机";
+            }else if(processMsgRet.equalsIgnoreCase("GN")) {
+                lmsg = "更换配件首件检查不合格停机";
+            }else if(processMsgRet.equalsIgnoreCase("DJ")) {
+                lmsg = "未进行开班点检";
+            }else if(processMsgRet.equalsIgnoreCase("BM")) {
+                lmsg = "未绑定物料";
+            }else if(processMsgRet.equalsIgnoreCase("PL")) {
+                lmsg = "配件寿命不足";
+            }else if(processMsgRet.equalsIgnoreCase("QM")) {
+                lmsg = "两次气密必须间隔15分钟";
+            }else if(processMsgRet.equalsIgnoreCase("GS")) {
+                lmsg = "工件码格式不正确";
+            }else if(processMsgRet.equalsIgnoreCase("CF")) {
+                lmsg = "工件码重复";
+            }
+
+            MesClient.setMenuStatus(lmsg,-1);
+        }catch (Exception e){
+            MesClient.setMenuStatus("未知错误",-1);
+        }
+    }
+}

src/com/mes/ui/LoginFarme.java

@@ -0,0 +1,217 @@
+package com.mes.ui;
+
+import com.alibaba.fastjson2.JSONObject;
+import com.mes.component.MesRadio;
+import com.mes.component.MesWebView;
+import com.mes.util.Base64Utils;
+import com.mes.util.HttpUtils;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+
+public class LoginFarme extends JFrame {
+    //登录模块组件
+    static JLabel userNameLabel= new JLabel("<html><body>用户名:</body></html>",JLabel.LEFT);//用户名
+    static JLabel userPasswordLabel= new JLabel("<html><body>密码:</body></html>",JLabel.LEFT);//用户名
+    public static JTextField userNameTxt;
+    public static JPasswordField userPasswordTxt;
+    static JButton loginButton = new JButton("用户密码登录");
+    static JButton scanLoginButton = new JButton("扫  码  登  录");
+
+    public LoginFarme(){
+        setTitle("MES系统客户端HEV："+MesClient.mes_gw+" - "+MesClient.mes_gw_des);
+
+        ImageIcon bg = new ImageIcon(MesClient.class.getResource("/background.png"));
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        JLabel imgLabel = new JLabel(bg);//将背景图放在标签里。
+        getLayeredPane().add(imgLabel, new Integer(Integer.MIN_VALUE));//注意这里是关键，将背景标签添加到jfram的LayeredPane面板里。
+        imgLabel.setBounds(0,0,bg.getIconWidth(), bg.getIconHeight());//设置背景标签的位置
+        Container contentPane=getContentPane();
+        contentPane.setLayout(null);//布局，很重要
+        JPanel welcomePanel = new JPanel();
+        //welcomePanel.setLayout(new GridLayout(3, 1));
+        welcomePanel.setLayout(null);
+        //welcomeLable.setBounds(10, 5, 700, 100);
+        welcomePanel.setBounds(30, 330, 890, 300);
+        welcomePanel.setOpaque(false);//背景透明
+        contentPane.add(welcomePanel);
+
+        //登录页面
+        userNameLabel.setBounds(300, 100, 120, 40);
+        userNameLabel.setFont(new java.awt.Font("Dialog",   1,   16));
+        userPasswordLabel.setBounds(300, 150, 120, 40);
+        userPasswordLabel.setFont(new java.awt.Font("Dialog",   1,   16));
+        userNameTxt = new JTextField(20);
+        userNameTxt.setText("");
+        userNameTxt.setBounds(400, 105, 150, 30);
+        userPasswordTxt = new JPasswordField(20);
+        userPasswordTxt.setBounds(400, 155, 150, 30);
+        userPasswordTxt.setText("");
+        loginButton.setFont(new java.awt.Font("Dialog",   1,   16));
+        loginButton.setBounds(300, 200, 255, 40);
+        loginButton.setIcon(new ImageIcon(MesClient.class.getResource("/bg/user.png")));
+
+//        scanLoginButton.setVisible(false);
+        scanLoginButton.setFont(new java.awt.Font("Dialog",   1,   16));
+        scanLoginButton.setBounds(300, 250, 255, 40);
+        scanLoginButton.setIcon(new ImageIcon(MesClient.class.getResource("/bg/scan_barcode.png")));
+
+        welcomePanel.add(userNameLabel);
+        welcomePanel.add(userPasswordLabel);
+        welcomePanel.add(userNameTxt);
+        welcomePanel.add(userPasswordTxt);
+        welcomePanel.add(loginButton);
+        welcomePanel.add(scanLoginButton);
+        loginButton.addActionListener(new ActionListener(){
+            public void actionPerformed(ActionEvent e) {
+                login();
+            }
+        });
+        scanLoginButton.addActionListener(new ActionListener(){
+            public void actionPerformed(ActionEvent e) {
+                scanLogin();
+            }
+        });
+
+        ((JPanel)contentPane).setOpaque(false); //注意这里，将内容面板设为透明。这样LayeredPane面板中的背景才能显示出来。
+        //welcomeWin.setSize(902,678);
+        setResizable(false);//禁止最大化
+        setIconImage(Toolkit.getDefaultToolkit().getImage(MesClient.class.getResource("/bg/logo.png")));
+
+        Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
+        int width = 902;
+        int height = 678;
+        setBounds((d.width-width)/2, (d.height-height)/2-(d.height-height)/4, width, height);
+        /*****正常模式******/
+        setVisible(true);
+    }
+
+    //登录
+    public static void login() {
+        String user_str = userNameTxt.getText().toString();
+        String password_str = userPasswordTxt.getText().toString();
+        if(user_str.equalsIgnoreCase("")||password_str.equalsIgnoreCase("")) {
+            JOptionPane.showMessageDialog(MesClient.mesClientFrame,"用户名或密码不能为空","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+            return;
+        }
+        String username = urlEncode(Base64Utils.getBase64(user_str));
+        String password = urlEncode(Base64Utils.getBase64(password_str));
+        System.out.println("&username=" + username + "&password=" + password);
+        String url = "http://"+MesClient.mes_server_ip+":8980/js/a/login?__ajax=json&username="+username+"&password="+password+"&validCode=&__sid=";
+        String loginResult = HttpUtils.sendRequest(url);
+        if(loginResult.equalsIgnoreCase("false")) {
+            JOptionPane.showMessageDialog(MesClient.mesClientFrame,"登录异常,请检查网络或联系网络管理员","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+            return;
+        }else {
+            JSONObject retObj = JSONObject.parseObject(loginResult);
+            if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
+                //检查用户权限是否可登录界面
+                checkUserAuthority(retObj);
+            }else {
+                //ret = "msg save error";
+                //ret = false;
+                JOptionPane.showMessageDialog(MesClient.mesClientFrame,"登录失败,用户名或密码错误","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+                return;
+            }
+        }
+    }
+    //扫码登录
+    public static void scanLogin() {
+        //userNameTxt.setText("");
+        //userPasswordTxt.setText("");
+        String scanContent = JOptionPane.showInputDialog(null, "请扫码工牌二维码");
+        System.out.println("scanContent="+scanContent);
+        if(scanContent!=null&&!scanContent.equalsIgnoreCase("")) {
+            String url = "http://"+MesClient.mes_server_ip+":8980/js/a/mes/mesLogin/login?__login=true&__ajax=json&username="+urlEncode(scanContent);
+            String loginResult = HttpUtils.sendRequest(url);
+            System.out.println("loginResult="+loginResult);
+            if(loginResult.equalsIgnoreCase("false")) {
+                JOptionPane.showMessageDialog(MesClient.mesClientFrame,"登录异常,请检查网络或联系网络管理员","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+                return;
+            }else {
+                JSONObject retObj = JSONObject.parseObject(loginResult);
+                if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
+                    //检查用户权限是否可登录界面
+                    checkUserAuthority(retObj);
+                }else {
+                    JOptionPane.showMessageDialog(MesClient.mesClientFrame,"登录失败,用户名或密码错误","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+                    return;
+                }
+            }
+        }else {
+            JOptionPane.showMessageDialog(MesClient.mesClientFrame,"扫码内容错误","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+            return;
+        }
+    }
+
+    //检查用户权限是否可登录界面
+    public static void checkUserAuthority(JSONObject retObj) {
+        //设置登录用户名
+        JSONObject userObj = JSONObject.parseObject(retObj.get("user").toString());
+        String user_id = userObj.getString("id").toString();
+
+        //获取sessionid，判断权限
+        MesClient.sessionid = retObj.get("sessionid").toString();
+        if(MesClient.sessionid!=null&&!MesClient.sessionid.equalsIgnoreCase("")) {
+            //请求权限
+            String url_authority = "http://"+MesClient.mes_server_ip+":8980/js/a/mes/mesLineProcess/userAuth?__ajax=json&type=0&__sid="+urlEncode(MesClient.sessionid)+"&oprno="+urlEncode(MesClient.mes_gw)+"&lineSn="+urlEncode(MesClient.mes_line_sn);
+            String authorityResult = HttpUtils.sendRequest(url_authority);
+            System.out.println("authorityResult="+authorityResult);
+            JSONObject authorityObj = JSONObject.parseObject(authorityResult);
+            if(authorityObj.get("result")!=null&&authorityObj.get("result").toString().equalsIgnoreCase("true")) {
+                JSONObject authObjTmp = JSONObject.parseObject(authorityObj.get("data").toString());
+                MesClient.mes_auth = Integer.parseInt(authObjTmp.getString("auth").toString());
+                if(MesClient.mes_auth==0) {
+                    //无权限登录
+                    JOptionPane.showMessageDialog(MesClient.mesClientFrame,"您无权登录该工位","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+                    return;
+                }else if(MesClient.mes_auth==1||MesClient.mes_auth==2) {
+                    //初始化tcp连接，发送同步报文
+                    MesClient.initTcpConnection();
+                    //启动timer心跳包
+                    MesClient.startHeartBeatTimer();
+
+                    //1操作工人,2管理员
+                    //登录成功
+                    MesClient.user_menu.setText(user_id);
+                    MesClient.welcomeWin.setVisible(false);
+                    MesClient.mesClientFrame.setVisible(true);
+                    MesClient.startGetCurSn();
+
+                    if(MesClient.jfxPanel == null){
+                        String url = "http://"+ MesClient.mes_server_ip+":8980/js/a/mes/mesProductRecord/work?__sid="+urlEncode(MesClient.sessionid)+"&oprno="+urlEncode(MesClient.mes_gw)+"&lineSn="+urlEncode(MesClient.mes_line_sn);
+                        MesClient.jfxPanel = new MesWebView(url);
+                        MesClient.jfxPanel.setSize(990, 550);
+                        MesClient.indexPanelB.add(MesClient.jfxPanel);
+                    }
+
+                    if(MesClient.jfxPanel2 == null){
+                        String url = "http://"+ MesClient.mes_server_ip+":8980/js/a/mes/mesProcessCheckRecord/ulist?__sid="+urlEncode(MesClient.sessionid)+"&oprno="+urlEncode(MesClient.mes_gw)+"&lineSn="+urlEncode(MesClient.mes_line_sn);
+                        MesClient.jfxPanel2 = new MesWebView(url);
+                        MesClient.jfxPanel2.setSize(990, 550);
+                        MesClient.indexPanelC.add(MesClient.jfxPanel2);
+                    }
+
+                    MesClient.initWarehouseData();
+                }
+
+            }
+
+        }else {
+            JOptionPane.showMessageDialog(MesClient.mesClientFrame,"登录失败,用户名或密码错误","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+            return;
+        }
+    }
+
+    private static String urlEncode(String value) {
+        try {
+            return URLEncoder.encode(value == null ? "" : value, "UTF-8");
+        } catch (UnsupportedEncodingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/com/mes/ui/MesRevice.java

@@ -0,0 +1,115 @@
+package com.mes.ui;
+
+import com.mes.netty.ProtocolParam;
+import com.mes.component.MyDialog;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class MesRevice {
+
+    // 质量查询
+    public static void checkQualityRevice(String processMsgRet,String mes_msg){
+        try{
+            if(processMsgRet.equalsIgnoreCase("UD")) {
+                MesClient.backendPollingSn = "";
+                MesClient.status_menu.setForeground(Color.GREEN);
+                MesClient.check_quality_result = true;//质量合格，可以绑定加工
+                MesClient.setMenuStatus("该工件可以加工",0);
+                if(MesClient.work_status == 0 ){
+                    MesClient.work_status = 1;
+                    MesClient.tjStatus = 0;
+                    ModbusUtil.prepareAndStartWork();
+                }
+            }else {
+                MesClient.check_quality_result = false;
+                MesClient.backendPollingSn = "";
+                if(!MesClient.curSn.isEmpty()){
+                    MesClient.lastRejectedBackendSn = MesClient.curSn.trim();
+                }
+                // 闭环：质量不合格时清除后台工位码，避免重复拉取同一件
+                MesClient.clearBackendCurSn();
+                MesClient.product_sn.setText("");
+                MesClient.curSn = "";
+                ErrorMsg.setErrorMsg(mes_msg);
+
+//                MesClient.deviceControl = ModbusUtil.getControlModel(MesClient.plcA);
+//                if(MesClient.deviceControl == 1){
+//
+//                }
+                ModbusUtil.setPowerOff(MesClient.plcA); // 远程关机
+                ModbusUtil.setPowerOff(MesClient.plcB); // 远程关机
+
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+    // 开始回复处理
+    public static void startRevice(String processMsgRet,String mes_msg){
+        try{
+            if(processMsgRet.equalsIgnoreCase("OK")) {
+                MesClient.work_status = 1;
+                MesClient.tjStatus = 0;
+
+//                MesClient.deviceControl = ModbusUtil.getControlModel(MesClient.plcA);
+//                if(MesClient.deviceControl == 1){
+//
+//                }
+
+//                MesClient.plcA.writeCoil(3128,false);
+//                MesClient.plcB.writeCoil(3128,false);
+
+                ModbusUtil.prepareAndStartWork();
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+    // 绑定
+    public static void bindRevice(String processMsgRet,String mes_msg){
+        try{
+            if(processMsgRet.equalsIgnoreCase("OK")) {
+
+            }else{
+
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+    // 解绑
+    public static void unbindRevice(String processMsgRet,String mes_msg){
+        try{
+            if(processMsgRet.equalsIgnoreCase("OK")) {
+
+            }else{
+
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+    // 上传质量
+    public static void updateResultRevice(String processMsgRet,String mes_msg){
+        try{
+            if(processMsgRet.equalsIgnoreCase("OK")) {
+
+                MesClient.resetScanA();
+                MesClient.setMenuStatus("结果提交成功，等待下一件",0);
+
+            }else{
+                MesClient.setMenuStatus("结果提交失败，请重试",-1);
+//                MesClient.status_menu.setText("结果提交失败，请重试");
+//                JOptionPane.showMessageDialog(MesClient.mesClientFrame,"结果提交失败，请重试","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+//                return;
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+}

src/com/mes/ui/ModbusUtil.java

@@ -0,0 +1,342 @@
+package com.mes.ui;
+
+import com.github.xingshuangs.iot.protocol.modbus.service.ModbusTcp;
+import com.mes.util.JdbcUtils;
+
+import javax.swing.*;
+import java.nio.charset.Charset;
+import java.util.List;
+
+public class ModbusUtil {
+
+    // 刷新界面拉力、行程显示
+    private static void updateForceStrokeDisplay(ModbusTcp plc, JTextField forceField, JTextField strokeField) {
+        if (forceField == null || strokeField == null) {
+            return;
+        }
+        try {
+            forceField.setText(plc.readInt16(1064) + "");
+            strokeField.setText((float) plc.readInt16(1065) / 1000 + "");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void getDataA(ModbusTcp plc){
+
+        // 说明预设数量有变化不能修改
+        // 打钉数应按实际监听数算
+
+        // 41065=F-out  41066=S-out
+        // 41069=F-min  41071=S-min 41070=F-max  41072=S-max
+        // 预设数量=41129  完成数=41137
+
+        Short cur = plc.readInt16(1136);
+        updateForceStrokeDisplay(plc, MesClient.param5, MesClient.param6);
+//        System.out.println("F-out:"+plc.readInt16(1064));
+//        System.out.println("S-out:"+plc.readInt16(1065));
+//        System.out.println("F-min:"+plc.readInt16(1068));
+//        System.out.println("S-min:"+plc.readInt16(1070));
+//        System.out.println("F-max:"+plc.readInt16(1069));
+//        System.out.println("S-max:"+plc.readInt16(1071));
+//        System.out.println("预设数量:"+plc.readInt16(1128));
+        //System.out.println("当前数量:"+cur);
+        if(MesClient.aMax <= 0){
+            MesClient.aMax = plc.readInt16(1128); // 任务数量
+            MesClient.param1.setText(String.valueOf(MesClient.aMax));
+        }
+        MesClient.param2.setText(cur + "");
+
+        if(MesClient.sortA == cur - 1){
+            MesClient.sortA = cur;
+            MesClient.aFinish = plc.readInt16(1138);
+            String fout = plc.readInt16(1064)+"";
+            String sout = (float)plc.readInt16(1065)/1000+"";
+
+            String fmin = plc.readInt16(1068)+"";
+            String smin = (float)plc.readInt16(1070)/1000+"";
+
+            String fmax = plc.readInt16(1069)+"";
+            String smax = (float)plc.readInt16(1071)/1000+"";
+
+            System.out.println("cur:"+cur);
+
+            int nextRivet = cur + 1;
+            if (nextRivet <= MesClient.aMax) {
+                applyParamsForRivet(plc, MesClient.rivetParamRangesA, nextRivet);
+            }
+
+            if(!MesClient.product_sn.getText().isEmpty()){
+                JdbcUtils.insertProdData(MesClient.mes_gw, MesClient.mes_line_sn, MesClient.product_sn.getText(),"A",fout,sout,fmin,smin,fmax,smax,"1",cur+"", MesClient.user_menu.getText());
+            }
+        }
+
+        upResult();
+    }
+
+    public static void getDataB(ModbusTcp plc){
+
+        // 41065=F-out  41066=S-out
+        // 41069=F-min  41071=S-min 41070=F-max  41072=S-max
+        // 预设数量=41129  完成数=41137
+
+        Short cur = plc.readInt16(1136);
+        updateForceStrokeDisplay(plc, MesClient.param7, MesClient.param8);
+//        System.out.println("F-out:"+plc.readInt16(1064));
+//        System.out.println("S-out:"+plc.readInt16(1065));
+//        System.out.println("F-min:"+plc.readInt16(1068));
+//        System.out.println("S-min:"+plc.readInt16(1070));
+//        System.out.println("F-max:"+plc.readInt16(1069));
+//        System.out.println("S-max:"+plc.readInt16(1071));
+//        System.out.println("set:"+plc.readInt16(1128));
+//        System.out.println("cur:"+cur);
+//        System.out.println("cur2:"+MesClient.sortB);
+
+        if(MesClient.bMax <= 0){
+            MesClient.bMax = plc.readInt16(1128);
+            MesClient.param3.setText(String.valueOf(MesClient.bMax));
+        }
+        MesClient.param4.setText(cur + "");
+
+        if(MesClient.sortB == cur - 1){
+            MesClient.sortB = cur;
+            String fout = plc.readInt16(1064)+"";
+            String sout = (float)plc.readInt16(1065)/1000+"";
+
+            String fmin = plc.readInt16(1068)+"";
+            String smin = (float)plc.readInt16(1070)/1000+"";
+
+            String fmax = plc.readInt16(1069)+"";
+            String smax = (float)plc.readInt16(1071)/1000+"";
+
+            int nextRivet = cur + 1;
+            if (nextRivet <= MesClient.bMax) {
+                applyParamsForRivet(plc, MesClient.rivetParamRangesB, nextRivet);
+            }
+
+            System.out.println("cur:"+cur);
+            if(!MesClient.product_sn.getText().isEmpty()){
+               JdbcUtils.insertProdData(MesClient.mes_gw, MesClient.mes_line_sn, MesClient.product_sn.getText(),"B",fout,sout,fmin,smin,fmax,smax,"1",cur+"", MesClient.user_menu.getText());
+            }
+        }
+
+        upResult();
+
+    }
+
+    // 上传总结果
+    public static void upResult(){
+        if(!MesClient.curSn.isEmpty() && MesClient.aMax > 0 && MesClient.aMax == MesClient.sortA && MesClient.bMax > 0 && MesClient.bMax == MesClient.sortB){
+            MesClient.finish_ok_bt.setEnabled(true);
+            MesClient.finish_ng_bt.setEnabled(true);
+
+            if(MesClient.tjStatus == 0 && MesClient.check_quality_result){
+                MesClient.tjStatus = 1;
+                String retf = "OK";
+                if(MesClient.aFinish != MesClient.aMax){
+                    retf = "NG";
+                }
+                MesClient.submitQualityResult(retf);
+            }
+
+        }
+    }
+
+    // 获取控制模式
+    public static short getControlModel(ModbusTcp plc){
+        short control = 0;
+        try{
+            control = plc.readInt16(1090);
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+
+        return control;
+    }
+
+    // 获取二维码
+    public static String getSn(ModbusTcp plc){
+        String sn = "";
+        try{
+            sn = plc.readString(1216,40, Charset.forName("UTF8"));
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+
+        return splitIntoChunks(sn,2);
+    }
+
+    // 每两个字符分割，并反转
+    private static String splitIntoChunks(String str, int chunkSize) {
+        if (str == null || str.isEmpty() || chunkSize <= 0) {
+            return "";
+        }
+
+        int length = str.length();
+        int arraySize = (length + chunkSize - 1) / chunkSize;
+        String[] result = new String[arraySize];
+
+        for (int i = 0, j = 0; i < length; i += chunkSize, j++) {
+            int endIndex = Math.min(i + chunkSize, length);
+            String sttr = str.substring(i, endIndex);
+            StringBuilder sb = new StringBuilder(sttr);
+            String reversedStr = sb.reverse().toString(); // 字符串反转
+            result[j] = reversedStr;
+        }
+
+        return String.join("",result);
+    }
+
+    // 远程开机
+    public static Boolean setPowerOn(ModbusTcp plc){
+        Boolean ret = false;
+        try{
+            plc.writeCoil(3128,true);
+//            plc.writeCoil(3079,false);
+//            plc.writeCoil(3328,true); // 必须选关掉关机，开机才起左右
+            ret = true;
+        }catch (Exception e){
+            e.printStackTrace();
+            ret = false;
+        }
+
+        return ret;
+    }
+
+    // 远程关机
+    public static Boolean setPowerOff(ModbusTcp plc){
+        if (MesClient.mes_shield_flag) {
+            System.out.println("MES屏蔽已开启，跳过关机指令");
+            return true;
+        }
+        Boolean ret = false;
+        try{
+            plc.writeCoil(3128,false);
+//            plc.writeCoil(3328,false);
+//            plc.writeCoil(3079,true); // 关机
+            // 必须选关掉关机，开机才起左右
+            ret = true;
+        }catch (Exception e){
+            e.printStackTrace();
+            ret = false;
+        }
+
+        return ret;
+    }
+
+    // 查找指定颗数对应的参数区间
+    public static RivetParamRange findRivetParamRange(List<RivetParamRange> ranges, int rivetNo) {
+        if (ranges == null) {
+            return null;
+        }
+        for (RivetParamRange range : ranges) {
+            if (range.contains(rivetNo)) {
+                return range;
+            }
+        }
+        return null;
+    }
+
+    // 获取指定枪的参数区间，必要时从数据库重新加载
+    private static List<RivetParamRange> getRivetParamRanges(String gunType) {
+        List<RivetParamRange> ranges = "A".equalsIgnoreCase(gunType)
+                ? MesClient.rivetParamRangesA : MesClient.rivetParamRangesB;
+        if (ranges == null || ranges.isEmpty()) {
+            MesClient.loadRivetParamConfig();
+            ranges = "A".equalsIgnoreCase(gunType)
+                    ? MesClient.rivetParamRangesA : MesClient.rivetParamRangesB;
+        }
+        return ranges;
+    }
+
+    // 扫码/开工：加载最新配置、远程开机并下发任务与第1颗拉力/行程参数
+    public static void prepareAndStartWork() {
+        MesClient.loadRivetParamConfig();
+        setPowerOn(MesClient.plcA);
+        setPowerOn(MesClient.plcB);
+        setTask(MesClient.plcA, MesClient.aSetNum, "A");
+        setTask(MesClient.plcB, MesClient.bSetNum, "B");
+        System.out.println("开工下发完成：A枪" + MesClient.aSetNum + "颗, B枪" + MesClient.bSetNum + "颗");
+    }
+
+    // 保存配置后，按PLC当前进度将对应颗数的拉力/行程参数立即下发
+    public static void syncRivetParamsToPlc(ModbusTcp plc, List<RivetParamRange> ranges) {
+        if (plc == null || ranges == null || ranges.isEmpty()) {
+            return;
+        }
+        try {
+            int rivetNo;
+            if (MesClient.work_status == 1) {
+                short cur = plc.readInt16(1136);
+                rivetNo = Math.max(cur + 1, 1);
+            } else {
+                // 非加工中按第1颗区间下发，避免沿用上次的完成颗数
+                rivetNo = 1;
+            }
+            applyParamsForRivet(plc, ranges, rivetNo);
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new RuntimeException(e);
+        }
+    }
+
+    // 按颗数下发PLC拉力/行程参数
+    public static void applyParamsForRivet(ModbusTcp plc, List<RivetParamRange> ranges, int rivetNo) {
+        RivetParamRange range = findRivetParamRange(ranges, rivetNo);
+        if (range == null) {
+            System.out.println("未找到第" + rivetNo + "颗对应的参数配置");
+            return;
+        }
+        try {
+            plc.writeInt16(1068, (short) range.getFMin());
+            plc.writeInt16(1069, (short) range.getFMax());
+            plc.writeInt16(1070, (short) range.getSMin());
+            plc.writeInt16(1071, (short) range.getSMax());
+            System.out.println("下发铆接参数：第" + rivetNo + "颗, F=" + range.getFMin() + "-" + range.getFMax()
+                    + ", S=" + range.getSMin() + "-" + range.getSMax());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    // 重置任务
+    public static void setTask(ModbusTcp plc, Short setNum, String gunType) {
+        try{
+            // 设置模式 1=标记铆接模式
+            plc.writeInt16(1092,(short) 1);
+            // 设置任务
+            plc.writeInt16(1128,setNum);
+            plc.writeInt16(1136,(short) 0);
+            plc.writeInt16(1138,(short) 0);
+
+            List<RivetParamRange> ranges = getRivetParamRanges(gunType);
+            applyParamsForRivet(plc, ranges, 1);
+
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+
+//        A枪说明 192.168.1.7
+//        plc.writeCoil(3079,false);
+//        plc.writeCoil(3328,true); // 必须选关掉关机，开机才起左右
+////        plc.writeCoil(3128,false);
+//        System.out.println("控制模式:"+plc.readInt16(1090)); // 1091 控制模式
+//        System.out.println("系统运行中:"+plc.readCoil(3128,1)); // 3129 系统运行中
+//        System.out.println("结束暂停:"+plc.readCoil(3132,1)); // 3133 系统运行中
+//        System.out.println("远程开机:"+plc.readCoil(3328,1)); // 3329 远程开机
+//        System.out.println("远程关机:"+plc.readCoil(3079,1)); // 3080 远程关机
+//        System.out.println("作业模式:"+plc.readInt16(1092)); // 1093 作业模式
+//        System.out.println("最大拉力:"+plc.readInt16(1064)); // 1065 最大拉力
+//        System.out.println("对应位移:"+plc.readInt16(1065)); // 1066 对应位移
+//        System.out.println("任务数量:"+plc.readInt16(1128)); // 1129 任务数量
+//        System.out.println("合格数量:"+plc.readInt16(1138)); // 1139 合格数量
+//        System.out.println("质量状态:"+plc.readInt16(1072)); // 1073 质量状态
+//        System.out.println("F-out:"+plc.readInt16(1064));
+//        System.out.println("S-out:"+plc.readInt16(1065));
+//        System.out.println("F-min:"+plc.readInt16(1068));
+//        System.out.println("S-min:"+plc.readInt16(1070));
+//        System.out.println("F-max:"+plc.readInt16(1069));
+//        System.out.println("S-max:"+plc.readInt16(1071));
+}

src/com/mes/ui/OprnoUtil.java

@@ -0,0 +1,68 @@
+package com.mes.ui;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class OprnoUtil {
+    public static String[] xtoprnos = new String[]{
+            "OP010", "OP030", "OP050", "OP060", "OP070",
+            "OP080", "OP090", "OP100", "OP110", "OP120",
+            "OP130", "OP140", "OP150", "OP160", "OP190",
+            "OP210", "OP220"
+    };
+
+    public static String[] xtoprnodes = new String[]{
+            "镭雕", "凸焊", "左右吊耳组件弧焊", "左右吊耳组件点焊", "电池壳分总成1点焊",
+            "电池壳分总成1点焊补焊", "电池壳分总成2点焊", "电池壳分总成2点焊补焊", "电池壳分总成3点焊", "电池壳分总成4点焊",
+            "电池壳分总成5点焊补焊", "电池壳分总成6弧焊", "电池壳分总成7弧焊", "电池壳分总成8弧焊", "气密检测",
+            "拉铆", "总成气密检测"
+    };
+    public static String[] oprnos = new String[]{
+            "OP040","OP050","OP060","OP070","OP080","OP090","OP100","OP110",
+            "OP120","OP130","OP140","OP150","OP160","OP170","OP180","OP190",
+            "OP200","OP210","OP220"
+    };
+    public static String[] oprnodes = new String[]{
+            "左右冷板FSW（反面）","左右冷板FSW（正面）","左右冷板正面CNC","左右冷板反面CNC","去毛刺吹铝屑","超声波清洗","冷板FSW堵头反面焊接","冷板FSW堵头正面焊接",
+            "打磨焊道","拉铆框架正面","底护板支撑柱+BDU柱+线束支架焊接","液冷板装配拉铆","冷板总成正面CNC","冷板总成反面CNC","去毛刺吹铝屑，清洁","高压冲洗",
+            "M5+M6钢丝牙套安装","冷板汽检","冷板氦检"
+    };
+    public static String getGwDes(String lineSn,String oprno){
+        String des = "";
+        oprno = formatOprno(oprno);
+        if(lineSn.equals("BE14XT")){
+            int i = 0;
+            for (String gw:xtoprnos){
+                if(gw.equals(oprno)){
+                    des = xtoprnodes[i];
+                    break;
+                }
+                i++;
+            }
+        }else if(lineSn.equals("BE14XT")){
+            int i = 0;
+            for (String gw:oprnos){
+                if(gw.equals(oprno)){
+                    des = oprnodes[i];
+                    break;
+                }
+                i++;
+            }
+        }
+        return des;
+    }
+
+    public static String formatOprno(String oprno){
+        List<String> lists = new ArrayList<>();
+
+        if(oprno.length() == 6){
+            String ysoprno = oprno.substring(0,5).trim();
+            if(!lists.contains(ysoprno)){
+                oprno = ysoprno;
+            }
+        }
+
+        return  oprno;
+    }
+}

src/com/mes/ui/ProdReq.java

@@ -0,0 +1,148 @@
+package com.mes.ui;
+
+public class ProdReq {
+    private Integer id;
+    private String gw;
+    private String lineSn;
+    private String type;
+    private String sn;
+    private String fout;
+    private String sout;
+    private String fmin;
+    private String smin;
+    private String fmax;
+    private String smax;
+    private String qty;
+    private String serialNumber;
+    private Integer sync;
+    private String recordTime;
+    private String ucode;
+
+    public String getUcode() {
+        return ucode;
+    }
+
+    public void setUcode(String ucode) {
+        this.ucode = ucode;
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getGw() {
+        return gw;
+    }
+
+    public void setGw(String gw) {
+        this.gw = gw;
+    }
+
+    public String getLineSn() {
+        return lineSn;
+    }
+
+    public void setLineSn(String lineSn) {
+        this.lineSn = lineSn;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getSn() {
+        return sn;
+    }
+
+    public void setSn(String sn) {
+        this.sn = sn;
+    }
+
+    public String getFout() {
+        return fout;
+    }
+
+    public void setFout(String fout) {
+        this.fout = fout;
+    }
+
+    public String getSout() {
+        return sout;
+    }
+
+    public void setSout(String sout) {
+        this.sout = sout;
+    }
+
+    public String getFmin() {
+        return fmin;
+    }
+
+    public void setFmin(String fmin) {
+        this.fmin = fmin;
+    }
+
+    public String getSmin() {
+        return smin;
+    }
+
+    public void setSmin(String smin) {
+        this.smin = smin;
+    }
+
+    public String getFmax() {
+        return fmax;
+    }
+
+    public void setFmax(String fmax) {
+        this.fmax = fmax;
+    }
+
+    public String getSmax() {
+        return smax;
+    }
+
+    public void setSmax(String smax) {
+        this.smax = smax;
+    }
+
+    public String getQty() {
+        return qty;
+    }
+
+    public void setQty(String qty) {
+        this.qty = qty;
+    }
+
+    public String getSerialNumber() {
+        return serialNumber;
+    }
+
+    public void setSerialNumber(String serialNumber) {
+        this.serialNumber = serialNumber;
+    }
+
+    public Integer getSync() {
+        return sync;
+    }
+
+    public void setSync(Integer sync) {
+        this.sync = sync;
+    }
+
+    public String getRecordTime() {
+        return recordTime;
+    }
+
+    public void setRecordTime(String recordTime) {
+        this.recordTime = recordTime;
+    }
+}

src/com/mes/ui/RivetParamRange.java

@@ -0,0 +1,87 @@
+package com.mes.ui;
+
+/**
+ * 拉铆枪按颗数区间的PLC参数配置
+ */
+public class RivetParamRange {
+    private String gunType;
+    private int startRivet;
+    private int endRivet;
+    private int fMin;
+    private int fMax;
+    private int sMin;
+    private int sMax;
+
+    public RivetParamRange() {
+    }
+
+    public RivetParamRange(String gunType, int startRivet, int endRivet, int fMin, int fMax, int sMin, int sMax) {
+        this.gunType = gunType;
+        this.startRivet = startRivet;
+        this.endRivet = endRivet;
+        this.fMin = fMin;
+        this.fMax = fMax;
+        this.sMin = sMin;
+        this.sMax = sMax;
+    }
+
+    public String getGunType() {
+        return gunType;
+    }
+
+    public void setGunType(String gunType) {
+        this.gunType = gunType;
+    }
+
+    public int getStartRivet() {
+        return startRivet;
+    }
+
+    public void setStartRivet(int startRivet) {
+        this.startRivet = startRivet;
+    }
+
+    public int getEndRivet() {
+        return endRivet;
+    }
+
+    public void setEndRivet(int endRivet) {
+        this.endRivet = endRivet;
+    }
+
+    public int getFMin() {
+        return fMin;
+    }
+
+    public void setFMin(int fMin) {
+        this.fMin = fMin;
+    }
+
+    public int getFMax() {
+        return fMax;
+    }
+
+    public void setFMax(int fMax) {
+        this.fMax = fMax;
+    }
+
+    public int getSMin() {
+        return sMin;
+    }
+
+    public void setSMin(int sMin) {
+        this.sMin = sMin;
+    }
+
+    public int getSMax() {
+        return sMax;
+    }
+
+    public void setSMax(int sMax) {
+        this.sMax = sMax;
+    }
+
+    public boolean contains(int rivetNo) {
+        return rivetNo >= startRivet && rivetNo <= endRivet;
+    }
+}

src/com/mes/ui/TableCellEditorButton.java

@@ -0,0 +1,43 @@
+package com.mes.ui;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class TableCellEditorButton extends DefaultCellEditor {
+    private JButton btn;
+    public TableCellEditorButton() {
+        super(new JTextField());
+        //设置点击一次就激活，否则默认好像是点击2次激活。
+        this.setClickCountToStart(1);
+        btn = new JButton("扫码");
+        btn.addActionListener(new ActionListener() {
+
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                System.out.println("按钮事件触发----");
+                int selectedRow = MesClient.table.getSelectedRow();//获得选中行的索引
+//                MesClient.rowData[selectedRow][1] = (new Date()).getTime();
+//                MesClient.table.repaint(); //重绘
+
+//                MesClient.scan_type = selectedRow + 4;
+                BindMaterialResp bindMaterialResp = new BindMaterialResp();
+                bindMaterialResp.setMaterialTitle(MesClient.rowData[selectedRow][0] + "");
+                bindMaterialResp.setBatchSn(MesClient.rowData[selectedRow][1] + "");
+                bindMaterialResp.setLastTimes(MesClient.rowData[selectedRow][2] + "");
+                bindMaterialResp.setCraft(MesClient.rowData[selectedRow][4] + "");
+                bindMaterialResp.setMaterialId(MesClient.rowData[selectedRow][5] + "");
+                bindMaterialResp.setType(MesClient.rowData[selectedRow][6] + "");
+
+                MesClient.scanBatchSn(bindMaterialResp);
+            }
+        });
+
+    }
+    @Override
+    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
+
+        return btn;
+    }
+}

src/com/mes/ui/TableCellRendererButton.java

@@ -0,0 +1,14 @@
+package com.mes.ui;
+
+import javax.swing.*;
+import javax.swing.table.TableCellRenderer;
+import java.awt.*;
+
+public class TableCellRendererButton implements TableCellRenderer {
+    @Override
+    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
+                                                   int row, int column) {
+        JButton button = new JButton("扫码");
+        return button;
+    }
+}

src/com/mes/util/Base64Utils.java

@@ -0,0 +1,17 @@
+package com.mes.util;
+
+import org.apache.commons.codec.binary.Base64;
+
+import java.nio.charset.StandardCharsets;
+
+public class Base64Utils {
+	public static String getBase64(String str) {
+		// 待编码的二进制数据
+        byte[] binaryData = str.getBytes(StandardCharsets.UTF_8);
+        // 使用Base64.encodeBase64String进行编码
+        String encodedString = Base64.encodeBase64String(binaryData);
+        // 输出编码后的结果
+        System.out.println("Base64编码结果： " + encodedString);
+        return encodedString;
+	}
+}

src/com/mes/util/DateLocalUtils.java

@@ -0,0 +1,34 @@
+package com.mes.util;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class DateLocalUtils {
+	public static SimpleDateFormat DATA_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
+	public static SimpleDateFormat DATA_FORMAT1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+	
+	
+	public static String getCurrentTime() {
+		String currentTime = DATA_FORMAT.format(new Date());
+		return currentTime;
+	}
+	
+	public static String getCurrentTime1() {
+		String currentTime = DATA_FORMAT1.format(new Date());
+		return currentTime;
+	}
+	
+	//获取当前时间，年月日
+	public static SimpleDateFormat DATA_FORMAT2 = new SimpleDateFormat("yyyy-MM-dd");
+	public static String getCurrentDate() {
+		String currentTime = DATA_FORMAT2.format(new Date());
+		return currentTime;
+	}
+	
+	//获取当前时间，时分秒
+	public static SimpleDateFormat DATA_FORMAT3 = new SimpleDateFormat("HH:mm:ss");
+	public static String getCurrentTimeHMS() {
+		String currentTime = DATA_FORMAT3.format(new Date());
+		return currentTime;
+	}
+}

src/com/mes/util/ErrorMsg.java

@@ -0,0 +1,45 @@
+package com.mes.util;
+
+public class ErrorMsg {
+    public static String getErrorMsg(String processMsgRet,String lx){
+        String lmsg = "该工件本工位不可加工";
+        try{
+            if(processMsgRet.equalsIgnoreCase("OK")||processMsgRet.equalsIgnoreCase("NG")) {
+                lmsg = "该工件本工位已加工，结果："+processMsgRet;
+            }else if(processMsgRet.equalsIgnoreCase("NE")) {
+                lmsg = "该工件未录入系统";
+            }else if(processMsgRet.equalsIgnoreCase("NN")) {
+                lmsg = "该工件跳过该工位";
+            }else if(processMsgRet.equalsIgnoreCase("QN")) {
+                lmsg = "该工件OP"+ lx+"0加工NG";
+            }else if(processMsgRet.equalsIgnoreCase("QD")) {
+                lmsg = "该工件OP"+ lx+"0未加工";
+            }else if(processMsgRet.equalsIgnoreCase("NF")) {
+                lmsg = "该工件已合格下线";
+            }else if(processMsgRet.equalsIgnoreCase("NR")) {
+                lmsg = "该工件离线返修中";
+            }else if(processMsgRet.equalsIgnoreCase("NB")) {
+                lmsg = "该工件已报废";
+            }else if(processMsgRet.equalsIgnoreCase("ND")) {
+                lmsg = "该工件NG待处理";
+            }else if(processMsgRet.equalsIgnoreCase("FN")) {
+                lmsg = "首件检查工件不合格停机";
+            }else if(processMsgRet.equalsIgnoreCase("GN")) {
+                lmsg = "更换配件首件检查不合格停机";
+            }else if(processMsgRet.equalsIgnoreCase("DJ")) {
+                lmsg = "未进行开班点检";
+            }else if(processMsgRet.equalsIgnoreCase("BM")) {
+                lmsg = "未绑定物料";
+            }else if(processMsgRet.equalsIgnoreCase("PL")) {
+                lmsg = "配件寿命不足";
+            }else if(processMsgRet.equalsIgnoreCase("QM")) {
+                lmsg = "两次气密必须间隔15分钟";
+            }else if(processMsgRet.equalsIgnoreCase("GS")) {
+                lmsg = "工件码格式不正确";
+            }else if(processMsgRet.equalsIgnoreCase("CF")) {
+                lmsg = "工件码重复";
+            }
+        }catch (Exception e){ }
+        return lmsg;
+    }
+}

src/com/mes/util/HttpUtils.java

@@ -0,0 +1,131 @@
+package com.mes.util;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.net.HttpURLConnection;
+import java.net.URISyntaxException;
+import java.net.URL;
+
+public class HttpUtils {
+	/**
+	 * HTTP请求，正确报文解析，并保存数据到生产记录数据
+	 * @return 
+	 * @throws URISyntaxException
+	 */
+    //http post请求
+    public static String sendRequest(String urlParam) {
+		String requestType = "POST";
+        //根据接收内容返回数据结果
+    	String ret = "";
+    	System.out.println(urlParam);
+        HttpURLConnection con = null;
+        BufferedReader buffer = null;
+        StringBuffer resultBuffer = null;
+        try {
+            URL url = new URL(urlParam);
+            //得到连接对象
+            con = (HttpURLConnection) url.openConnection();
+            //设置请求类型
+            con.setRequestMethod(requestType);
+            //设置请求需要返回的数据类型和字符集类型
+            con.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
+            //允许写出
+            con.setDoOutput(true);
+            //允许读入
+            con.setDoInput(true);
+            //不使用缓存
+            con.setUseCaches(false);
+            //得到响应码
+            int responseCode = con.getResponseCode();
+            System.out.println("responseCode="+responseCode);
+            if(responseCode == HttpURLConnection.HTTP_OK){
+                //得到响应流
+                InputStream inputStream = con.getInputStream();
+                //将响应流转换成字符串
+                resultBuffer = new StringBuffer();
+                String line;
+                buffer = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
+                while ((line = buffer.readLine()) != null) {
+                    resultBuffer.append(line);
+                }
+                System.out.println(resultBuffer.toString());
+                ret = resultBuffer.toString();
+            }else {
+            	//ret = String.valueOf(responseCode);
+            	ret = "false";
+            }
+            con.disconnect();
+        }catch(Exception e) {
+        	//ret = false;
+        	//System.out.println("e.toString()="+e.toString());
+        	//return e.toString();
+            //e.printStackTrace();
+        	ret = "false";
+        }
+        return ret;
+    }
+
+
+    public static String sendPostRequest(String urlParam, String params) {
+        String requestType = "POST";
+        //根据接收内容返回数据结果
+        String ret = "";
+        System.out.println(urlParam);
+        HttpURLConnection con = null;
+        BufferedReader buffer = null;
+        StringBuffer resultBuffer = null;
+        try {
+            URL url = new URL(urlParam);
+            //得到连接对象
+            con = (HttpURLConnection) url.openConnection();
+            //设置请求类型
+            con.setRequestMethod(requestType);
+            //设置请求需要返回的数据类型和字符集类型
+            con.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
+            //允许写出
+            con.setDoOutput(true);
+            //允许读入
+            con.setDoInput(true);
+            //不使用缓存
+            con.setUseCaches(false);
+
+            // 获取URLConnection对象对应的输出流
+            OutputStreamWriter out = new OutputStreamWriter( con.getOutputStream(),"UTF-8");// utf-8编码
+            // 发送请求参数
+            out.write(params);
+
+            //得到响应码
+            int responseCode = con.getResponseCode();
+            System.out.println("responseCode="+responseCode);
+            if(responseCode == HttpURLConnection.HTTP_OK){
+                //得到响应流
+                InputStream inputStream = con.getInputStream();
+                //将响应流转换成字符串
+                resultBuffer = new StringBuffer();
+                String line;
+                buffer = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
+                while ((line = buffer.readLine()) != null) {
+                    resultBuffer.append(line);
+                }
+                System.out.println(resultBuffer.toString());
+                ret = resultBuffer.toString();
+            }else {
+                //ret = String.valueOf(responseCode);
+                ret = "false";
+            }
+            con.disconnect();
+        }catch(Exception e) {
+            //ret = false;
+            //System.out.println("e.toString()="+e.toString());
+            //return e.toString();
+            //e.printStackTrace();
+            ret = "false";
+        }
+        return ret;
+    }
+
+	
+
+}

src/com/mes/util/JdbcUtils.java

@@ -0,0 +1,348 @@
+package com.mes.util;
+
+import com.mes.ui.ProdReq;
+import com.mes.ui.RivetParamRange;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.List;
+
+public class JdbcUtils {
+	//通过上面的工具就可以获取到properties文件中的键值从而可以加载驱动 获取链接 从而 可以增删改查
+	public static Connection conn = null;
+    public static String Drivde="org.sqlite.JDBC";
+    
+    public static Connection getConn(){
+        try {
+            // 复用已打开连接，避免每次新建导致多连接争用、保存失败却仍提示成功
+            if (conn != null && !conn.isClosed()) {
+                return conn;
+            }
+            Class.forName(Drivde);// 加载驱动,连接sqlite的jdbc
+            conn = DriverManager.getConnection("jdbc:sqlite:mes_db.db");//连接数据库zhou.db,不存在则创建
+            // 忙碌时等待，降低与定时任务并发写库被锁失败的概率
+            try (Statement busyStmt = conn.createStatement()) {
+                busyStmt.execute("PRAGMA busy_timeout = 5000");
+            }
+            System.out.println("连接到SQLite数据库成功！");
+            create_bw_record();//初始化结构表
+            create_bw_prod();
+            create_config_table();
+            create_rivet_param_table();
+        } catch (Exception e) {
+            // TODO Auto-generated catch block
+        	close();//关闭数据库连接
+            e.printStackTrace();
+        }
+        return conn;
+    }
+    
+    public static void create_bw_record() throws SQLException {
+    	Statement statement=conn.createStatement();   //创建连接对象，是Java的一个操作数据库的重要接口
+        //设备结构数据库
+        String sqlEquipment = "CREATE TABLE if not exists bw_record("
+        		+ "id INTEGER PRIMARY KEY AUTOINCREMENT,gw VARCHAR(20),gy VARCHAR(20),message_type VARCHAR(20),sn VARCHAR(48),bw VARCHAR(1000),record_time DATETIME,"
+        		+ "info_01 VARCHAR(200),info_02 VARCHAR(200),info_03 VARCHAR(200))";
+//        statement.executeUpdate("drop table if exists bw_record");//判断是否有表tables的存在。有则删除
+        statement.executeUpdate(sqlEquipment);
+        System.out.println("表record创建成功！");
+        statement.close();
+    }
+    
+    //插入数据
+    public static boolean insertData(String gw, String gy, String bw, String message_type, String sn) {
+    	boolean ret = false;
+    	String record_time = DateLocalUtils.getCurrentTime();
+    	if(conn==null) {
+    		ret = false;
+    	}else {
+    		try {
+    			//创建连接对象，是Java的一个操作数据库的重要接口
+				Statement statement=conn.createStatement();
+				statement.executeUpdate("INSERT INTO bw_record (gw,gy,bw,record_time,message_type,sn) VALUES"
+						+ " ('"+gw+"', '"+gy+"', '"+bw+"', '"+record_time+"','"+message_type+"','"+sn+"')");//向数据库中插入数据
+				statement.close();
+				ret = true;
+			} catch (SQLException e) {
+				// TODO Auto-generated catch block
+				//e.printStackTrace();
+				ret = false;
+			}   
+    	}
+    	
+    	return ret;
+    }
+
+	public static void create_bw_prod() throws SQLException {
+		Statement statement=conn.createStatement();   //创建连接对象，是Java的一个操作数据库的重要接口
+		//设备结构数据库
+		String sqlEquipment = "CREATE TABLE if not exists bw_prod("
+				+ "id INTEGER PRIMARY KEY AUTOINCREMENT,gw VARCHAR(20),line_sn VARCHAR(20),type VARCHAR(20),sn VARCHAR(48),"
+				+ "fout VARCHAR(20),sout VARCHAR(20),fmin VARCHAR(20),smin VARCHAR(20),fmax VARCHAR(20),smax VARCHAR(20),"
+				+ "qty VARCHAR(5),serial_number VARCHAR(50),sync int(10) NULL DEFAULT 0,record_time DATETIME,ucode VARCHAR(50))";   // 0=未同步到MES 1=已同步到MES
+		//statement.executeUpdate("drop table if exists bw_prod");//判断是否有表tables的存在。有则删除
+		statement.executeUpdate(sqlEquipment);
+		System.out.println("表prod创建成功！");
+		statement.close();
+	}
+    
+	public static void create_config_table() throws SQLException {
+		Statement statement = conn.createStatement();
+		String sql = "CREATE TABLE if not exists bw_config("
+				+ "id INTEGER PRIMARY KEY AUTOINCREMENT, "
+				+ "a_set_num SHORT, "
+				+ "b_set_num SHORT, "
+				+ "plc_ip_a VARCHAR(20), "
+				+ "plc_ip_b VARCHAR(20))";
+		statement.executeUpdate(sql);
+		
+		// 检查是否已有数据，若无则插入默认值
+		ResultSet rs = statement.executeQuery("SELECT count(*) FROM bw_config");
+		if (rs.next() && rs.getInt(1) == 0) {
+			statement.executeUpdate("INSERT INTO bw_config (a_set_num, b_set_num, plc_ip_a, plc_ip_b) "
+					+ "VALUES (40, 22, '192.168.1.7', '192.168.1.8')");
+		}
+		rs.close();
+		System.out.println("表config创建并初始化成功！");
+		statement.close();
+	}
+
+	public static java.util.Map<String, Object> getConfig() {
+		java.util.Map<String, Object> config = new java.util.HashMap<>();
+		String sql = "SELECT a_set_num, b_set_num, plc_ip_a, plc_ip_b FROM bw_config LIMIT 1";
+		Connection conn = JdbcUtils.getConn();
+		try (Statement stmt = conn.createStatement();
+			 ResultSet rs = stmt.executeQuery(sql)) {
+			if (rs.next()) {
+				config.put("a_set_num", rs.getShort("a_set_num"));
+				config.put("b_set_num", rs.getShort("b_set_num"));
+				config.put("plc_ip_a", rs.getString("plc_ip_a"));
+				config.put("plc_ip_b", rs.getString("plc_ip_b"));
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return config;
+	}
+
+	// 铆接参数区间配置表
+	public static void create_rivet_param_table() throws SQLException {
+		Statement statement = conn.createStatement();
+		String sql = "CREATE TABLE if not exists bw_rivet_param("
+				+ "id INTEGER PRIMARY KEY AUTOINCREMENT, "
+				+ "gun_type VARCHAR(1), "
+				+ "start_rivet INTEGER, "
+				+ "end_rivet INTEGER, "
+				+ "f_min INTEGER, "
+				+ "f_max INTEGER, "
+				+ "s_min INTEGER, "
+				+ "s_max INTEGER, "
+				+ "sort_order INTEGER)";
+		statement.executeUpdate(sql);
+
+		ResultSet rs = statement.executeQuery("SELECT count(*) FROM bw_rivet_param");
+		if (rs.next() && rs.getInt(1) == 0) {
+			statement.executeUpdate("INSERT INTO bw_rivet_param (gun_type,start_rivet,end_rivet,f_min,f_max,s_min,s_max,sort_order) VALUES "
+					+ "('A',1,41,10000,12000,3500,5500,1),"
+					+ "('B',1,14,11000,13000,3500,5500,1)");
+		}
+		rs.close();
+		System.out.println("表rivet_param创建并初始化成功！");
+		statement.close();
+	}
+
+	public static java.util.List<RivetParamRange> getRivetParams(String gunType) {
+		java.util.List<RivetParamRange> list = new java.util.ArrayList<>();
+		String sql = "SELECT gun_type,start_rivet,end_rivet,f_min,f_max,s_min,s_max FROM bw_rivet_param "
+				+ "WHERE gun_type = ? ORDER BY sort_order ASC, start_rivet ASC";
+		Connection conn = JdbcUtils.getConn();
+		try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+			pstmt.setString(1, gunType);
+			ResultSet rs = pstmt.executeQuery();
+			while (rs.next()) {
+				RivetParamRange range = new RivetParamRange();
+				range.setGunType(rs.getString("gun_type"));
+				range.setStartRivet(rs.getInt("start_rivet"));
+				range.setEndRivet(rs.getInt("end_rivet"));
+				range.setFMin(rs.getInt("f_min"));
+				range.setFMax(rs.getInt("f_max"));
+				range.setSMin(rs.getInt("s_min"));
+				range.setSMax(rs.getInt("s_max"));
+				list.add(range);
+			}
+			rs.close();
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return list;
+	}
+
+	public static synchronized boolean saveRivetParams(String gunType, java.util.List<RivetParamRange> ranges) {
+		Connection conn = JdbcUtils.getConn();
+		if (conn == null) {
+			System.out.println("保存铆接参数失败：数据库未连接, gunType=" + gunType);
+			return false;
+		}
+		try {
+			boolean oldAutoCommit = conn.getAutoCommit();
+			conn.setAutoCommit(false);
+			try {
+				PreparedStatement deleteStmt = conn.prepareStatement("DELETE FROM bw_rivet_param WHERE gun_type = ?");
+				deleteStmt.setString(1, gunType);
+				deleteStmt.executeUpdate();
+				deleteStmt.close();
+
+				String insertSql = "INSERT INTO bw_rivet_param (gun_type,start_rivet,end_rivet,f_min,f_max,s_min,s_max,sort_order) "
+						+ "VALUES (?,?,?,?,?,?,?,?)";
+				PreparedStatement insertStmt = conn.prepareStatement(insertSql);
+				for (int i = 0; i < ranges.size(); i++) {
+					RivetParamRange range = ranges.get(i);
+					insertStmt.setString(1, gunType);
+					insertStmt.setInt(2, range.getStartRivet());
+					insertStmt.setInt(3, range.getEndRivet());
+					insertStmt.setInt(4, range.getFMin());
+					insertStmt.setInt(5, range.getFMax());
+					insertStmt.setInt(6, range.getSMin());
+					insertStmt.setInt(7, range.getSMax());
+					insertStmt.setInt(8, i + 1);
+					insertStmt.executeUpdate();
+				}
+				insertStmt.close();
+				conn.commit();
+				System.out.println("保存铆接参数成功：gunType=" + gunType + ", rows=" + ranges.size());
+				return true;
+			} catch (SQLException e) {
+				try {
+					conn.rollback();
+				} catch (SQLException rollbackEx) {
+					rollbackEx.printStackTrace();
+				}
+				throw e;
+			} finally {
+				conn.setAutoCommit(oldAutoCommit);
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+			System.out.println("保存铆接参数失败：gunType=" + gunType + ", err=" + e.getMessage());
+			return false;
+		}
+	}
+
+	public static synchronized boolean updateConfig(short aSetNum, short bSetNum, String plcIpA, String plcIpB) {
+		String sql = "UPDATE bw_config SET a_set_num = ?, b_set_num = ?, plc_ip_a = ?, plc_ip_b = ? WHERE id = 1";
+		Connection conn = JdbcUtils.getConn();
+		if (conn == null) {
+			System.out.println("更新本地配置失败：数据库未连接");
+			return false;
+		}
+		try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+			pstmt.setShort(1, aSetNum);
+			pstmt.setShort(2, bSetNum);
+			pstmt.setString(3, plcIpA);
+			pstmt.setString(4, plcIpB);
+			int rows = pstmt.executeUpdate();
+			if (rows <= 0) {
+				System.out.println("更新本地配置失败：未更新到任何行");
+				return false;
+			}
+			System.out.println("更新本地配置成功：aSetNum=" + aSetNum + ", bSetNum=" + bSetNum + ", IP_A=" + plcIpA + ", IP_B=" + plcIpB);
+			return true;
+		} catch (SQLException e) {
+			e.printStackTrace();
+			System.out.println("更新本地配置失败：" + e.getMessage());
+			return false;
+		}
+	}
+
+    public static void close(){
+    	System.out.println("SQLite数据库连接关闭！");
+        try {
+        	if(conn!=null) {
+        		conn.close();
+        		conn = null;
+        	}
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+	//插入拉铆数据
+	public static boolean insertProdData(String gw, String lineSn, String sn, String type, String fout, String sout, String fmin, String smin, String fmax, String smax,String qty,String serial_number,String ucode) {
+		boolean ret = false;
+		String record_time = DateLocalUtils.getCurrentTime();
+		JdbcUtils.getConn();
+
+		if(conn==null) {
+			ret = false;
+		}else {
+			try {
+				//创建连接对象，是Java的一个操作数据库的重要接口
+				Statement statement=conn.createStatement();
+				statement.executeUpdate("INSERT INTO bw_prod (gw,line_sn,type,sn,fout,sout,fmin,smin,fmax,smax,qty,serial_number,ucode,record_time) VALUES"
+						+ " ('"+gw+"', '"+lineSn+"', '"+type+"', '"+sn+"', '"+fout+"', '"+sout+"', '"+fmin+"', '"+smin+"', '"+fmax+"', '"+smax+"', '"+qty+"','"+serial_number+"','"+ucode+"','"+record_time+"')");//向数据库中插入数据
+				statement.close();
+				ret = true;
+			} catch (SQLException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+				ret = false;
+			}
+		}
+
+		return ret;
+	}
+
+	public static void updateProdSync(Integer id,Integer sync) throws SQLException {
+		Connection conn = JdbcUtils.getConn();
+		Statement statement=conn.createStatement();   //创建连接对象，是Java的一个操作数据库的重要接口
+		statement.executeUpdate("update bw_prod set sync = "+sync + " where id = "+id);
+		statement.close();
+	}
+
+	public static List<ProdReq> getProds() {
+		//SQL语句
+		String sql = "select id,gw,line_sn,type,sn,fout,sout,fmin,smin,fmax,smax,qty,serial_number,sync,record_time,ucode from bw_prod where sync = 0 order by id asc limit 100";
+		Connection conn = JdbcUtils.getConn();
+		Statement stmt=null;
+		ResultSet ret = null;
+		String password=null;
+		List<ProdReq> prods = new ArrayList<>();
+		try {
+			stmt = conn.createStatement();
+			//执行语句，得到结果集
+			ret = stmt.executeQuery(sql);
+			System.out.println("sql:"+ sql);
+			while (ret.next()) {
+				ProdReq prodReq = new ProdReq();
+				prodReq.setId(ret.getInt(1));
+				prodReq.setGw(ret.getString(2));
+				prodReq.setLineSn(ret.getString(3));
+				prodReq.setType(ret.getString(4));
+				prodReq.setSn(ret.getString(5));
+				prodReq.setFout(ret.getString(6));
+				prodReq.setSout(ret.getString(7));
+				prodReq.setFmin(ret.getString(8));
+				prodReq.setSmin(ret.getString(9));
+				prodReq.setFmax(ret.getString(10));
+				prodReq.setSmax(ret.getString(11));
+				prodReq.setQty(ret.getString(12));
+				prodReq.setSerialNumber(ret.getString(13));
+				prodReq.setSync(ret.getInt(14));
+				prodReq.setRecordTime(ret.getString(15));
+				prodReq.setUcode(ret.getString(16));
+				prods.add(prodReq);
+			}
+			ret.close();
+			// 共享连接不要在这里关闭，否则后续保存配置会写失败
+			if (stmt != null) {
+				stmt.close();
+			}
+		} catch (SQLException e1) {
+			e1.printStackTrace();
+		}
+		return prods;
+	}
+
+}
+ 
+

src/resources/config/config.properties

@@ -0,0 +1,6 @@
+mes.gw=OP150A
+#mes.server_ip=127.0.0.1
+mes.server_ip=192.168.9.180
+mes.tcp_port=3000
+mes.heart_beat_cycle=60
+mes.line_sn=BE14XT