初始化

.classpath

@@ -0,0 +1,24 @@
+<?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"/>
+</classpath>

.gitignore

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

.project

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>mesclient-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>1778545721511</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/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/CheckRecordData.java

@@ -0,0 +1,52 @@
+package com.mes.ui;
+
+/**
+ * 点检记录数据实体类
+ */
+public class CheckRecordData {
+    private String id;
+    private String checkItem;   // 检查项
+    private String checkResult; // 检查结果
+    private String updateBy;    // 作业人员
+    private String updateDate;  // 日期
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getCheckItem() {
+        return checkItem;
+    }
+
+    public void setCheckItem(String checkItem) {
+        this.checkItem = checkItem;
+    }
+
+    public String getCheckResult() {
+        return checkResult;
+    }
+
+    public void setCheckResult(String checkResult) {
+        this.checkResult = checkResult;
+    }
+
+    public String getUpdateBy() {
+        return updateBy;
+    }
+
+    public void setUpdateBy(String updateBy) {
+        this.updateBy = updateBy;
+    }
+
+    public String getUpdateDate() {
+        return updateDate;
+    }
+
+    public void setUpdateDate(String updateDate) {
+        this.updateDate = updateDate;
+    }
+}

src/com/mes/ui/CheckRecordPanel.java

@@ -0,0 +1,312 @@
+package com.mes.ui;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.swing.*;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.DefaultTableModel;
+import javax.swing.table.TableColumn;
+import java.awt.*;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
+import java.util.List;
+
+/**
+ * 点检记录面板组件
+ * 支持分页查询和展示点检记录数据
+ */
+public class CheckRecordPanel extends JPanel {
+
+    private static final Logger log = LoggerFactory.getLogger(CheckRecordPanel.class);
+
+    // 表格列名
+    private static final String[] COLUMN_NAMES = {"检查项", "检查结果", "作业人员", "日期"};
+
+    // 分页配置
+    private static final int PAGE_SIZE = 20;
+
+    // 查询条件
+    private String oprno;  // 工位号
+    private String lineSn; // 产线编号
+
+    // 分页状态
+    private int pageNo = 1;
+    private long totalCount = 0;
+    private int totalPages = 0;
+
+    // UI组件
+    private JTable table;
+    private DefaultTableModel tableModel;
+    private JLabel pageLabel;
+    private JButton btnPrevious;
+    private JButton btnNext;
+    private JButton btnRefresh;
+    private JLabel statusLabel;
+
+    /**
+     * 构造函数
+     * @param oprno 工位号
+     * @param lineSn 产线编号
+     */
+    public CheckRecordPanel(String oprno, String lineSn) {
+        this.oprno = oprno;
+        this.lineSn = lineSn;
+        initUI();
+    }
+
+    /**
+     * 初始化UI
+     */
+    private void initUI() {
+        setLayout(null);
+        setBackground(Color.WHITE);
+
+        // 顶部控制区
+        JPanel topPanel = new JPanel();
+        topPanel.setLayout(null);
+        topPanel.setBounds(0, 0, 1200, 70);
+        topPanel.setBackground(new Color(248, 248, 248));
+        add(topPanel);
+
+        int xPos = 10;
+
+        // 状态标签
+        statusLabel = new JLabel("工位：" + oprno);
+        statusLabel.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        statusLabel.setBounds(xPos, 10, 250, 30);
+        topPanel.add(statusLabel);
+        xPos += 260;
+
+        // 刷新按钮
+        btnRefresh = new JButton("刷新");
+        btnRefresh.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        btnRefresh.setBounds(xPos, 10, 120, 40);
+        btnRefresh.addActionListener(e -> {
+            refreshData();
+        });
+        topPanel.add(btnRefresh);
+        xPos += 130;
+
+        // 上一页按钮
+        btnPrevious = new JButton("上一页");
+        btnPrevious.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        btnPrevious.setBounds(xPos, 10, 120, 40);
+        btnPrevious.addActionListener(e -> {
+            if (pageNo > 1) {
+                pageNo--;
+                loadData();
+            }
+        });
+        topPanel.add(btnPrevious);
+        xPos += 130;
+
+        // 页码显示
+        pageLabel = new JLabel("0/0");
+        pageLabel.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        pageLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        pageLabel.setBorder(BorderFactory.createLineBorder(Color.GRAY, 1));
+        pageLabel.setBounds(xPos, 10, 120, 40);
+        topPanel.add(pageLabel);
+        xPos += 130;
+
+        // 下一页按钮
+        btnNext = new JButton("下一页");
+        btnNext.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        btnNext.setBounds(xPos, 10, 120, 40);
+        btnNext.addActionListener(e -> {
+            if (pageNo < totalPages) {
+                pageNo++;
+                loadData();
+            }
+        });
+        topPanel.add(btnNext);
+
+        // 表格面板
+        JPanel tablePanel = new JPanel();
+        tablePanel.setBounds(0, 50, 1200, 518);
+        tablePanel.setLayout(new GridLayout(1, 1, 0, 0));
+        add(tablePanel);
+
+        // 创建表格模型
+        tableModel = new DefaultTableModel(COLUMN_NAMES, 0) {
+            @Override
+            public boolean isCellEditable(int row, int column) {
+                return false;
+            }
+        };
+
+        // 创建表格
+        table = new JTable(tableModel);
+        table.setRowHeight(32);
+        table.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        table.getTableHeader().setFont(new Font("微软雅黑", Font.BOLD, 30));
+        table.getTableHeader().setReorderingAllowed(false);
+
+        // 设置列宽
+        setColumnWidths();
+
+        // 设置居中渲染器
+        DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
+        centerRenderer.setHorizontalAlignment(JLabel.CENTER);
+        for (int i = 0; i < table.getColumnCount(); i++) {
+            table.getColumnModel().getColumn(i).setCellRenderer(centerRenderer);
+        }
+
+        // 添加滚动面板
+        JScrollPane scrollPane = new JScrollPane(table);
+        tablePanel.add(scrollPane);
+
+        // 添加组件大小变化监听器
+        addComponentListener(new ComponentAdapter() {
+            @Override
+            public void componentResized(ComponentEvent e) {
+                int w = getWidth();
+                int h = getHeight();
+
+                // 调整顶部面板宽度
+                topPanel.setBounds(0, 0, w, 60);
+
+                // 调整表格面板
+                if (h > 50) {
+                    tablePanel.setBounds(0, 60, w, h - 60);
+                }
+
+                topPanel.revalidate();
+                tablePanel.revalidate();
+            }
+        });
+    }
+
+    /**
+     * 设置列宽
+     */
+    private void setColumnWidths() {
+        TableColumn column;
+        // 检查项
+        column = table.getColumnModel().getColumn(0);
+        column.setPreferredWidth(300);
+        // 检查结果
+        column = table.getColumnModel().getColumn(1);
+        column.setPreferredWidth(100);
+        // 作业人员
+        column = table.getColumnModel().getColumn(2);
+        column.setPreferredWidth(100);
+        // 日期
+        column = table.getColumnModel().getColumn(3);
+        column.setPreferredWidth(150);
+    }
+
+    /**
+     * 刷新数据（重置到第一页）
+     */
+    public void refreshData() {
+        pageNo = 1;
+        loadData();
+    }
+
+    /**
+     * 加载数据
+     */
+    public void loadData() {
+        // 在后台线程中执行数据加载
+        SwingWorker<CheckRecordResp, Void> worker = new SwingWorker<CheckRecordResp, Void>() {
+            @Override
+            protected CheckRecordResp doInBackground() throws Exception {
+                // 更新状态
+                SwingUtilities.invokeLater(() -> {
+                    statusLabel.setText("正在加载...");
+                    setButtonsEnabled(false);
+                });
+
+                // 调用接口查询数据
+                return DataUtil.getCheckRecordList(oprno, pageNo, PAGE_SIZE);
+            }
+
+            @Override
+            protected void done() {
+                try {
+                    CheckRecordResp resp = get();
+                    updateUI(resp);
+                } catch (Exception e) {
+                    log.error("加载点检记录失败: {}", e.getMessage());
+                    updateUIError("加载失败: " + e.getMessage());
+                }
+            }
+        };
+        worker.execute();
+    }
+
+    /**
+     * 设置按钮启用状态
+     */
+    private void setButtonsEnabled(boolean enabled) {
+        btnRefresh.setEnabled(enabled);
+        btnPrevious.setEnabled(enabled && pageNo > 1);
+        btnNext.setEnabled(enabled && pageNo < totalPages);
+    }
+
+    /**
+     * 更新UI显示数据
+     */
+    private void updateUI(CheckRecordResp resp) {
+        // 清空表格
+        tableModel.setRowCount(0);
+
+        if (resp == null || !resp.isResult()) {
+            String msg = resp != null ? resp.getMessage() : "请求失败";
+            updateUIError(msg);
+            return;
+        }
+
+        // 更新分页信息
+        totalCount = resp.getCount();
+        totalPages = (int) Math.ceil((double) totalCount / PAGE_SIZE);
+        if (totalPages == 0) totalPages = 1;
+
+        // 更新页码显示
+        pageLabel.setText(pageNo + "/" + totalPages);
+
+        // 更新按钮状态
+        setButtonsEnabled(true);
+
+        // 更新状态标签
+        statusLabel.setText("工位：" + oprno + " 共" + totalCount + "条");
+
+        // 填充表格数据
+        List<CheckRecordData> list = resp.getList();
+        if (list != null && !list.isEmpty()) {
+            for (CheckRecordData data : list) {
+                Object[] row = {
+                        data.getCheckItem(),
+                        data.getCheckResult(),
+                        data.getUpdateBy(),
+                        data.getUpdateDate()
+                };
+                tableModel.addRow(row);
+            }
+        }
+
+        // 刷新表格
+        table.repaint();
+    }
+
+    /**
+     * 更新UI显示错误信息
+     */
+    private void updateUIError(String message) {
+        statusLabel.setText("错误: " + message);
+        pageLabel.setText("0/0");
+        setButtonsEnabled(true);
+        btnPrevious.setEnabled(false);
+        btnNext.setEnabled(false);
+        tableModel.setRowCount(0);
+    }
+
+    /**
+     * 获取当前工位号
+     */
+    public String getOprno() {
+        return oprno;
+    }
+}

src/com/mes/ui/CheckRecordResp.java

@@ -0,0 +1,63 @@
+package com.mes.ui;
+
+import java.util.List;
+
+/**
+ * 点检记录查询响应实体类
+ */
+public class CheckRecordResp {
+    private boolean result;
+    private String message;
+    private int pageNo;
+    private int pageSize;
+    private long count;
+    private List<CheckRecordData> list;
+
+    public boolean isResult() {
+        return result;
+    }
+
+    public void setResult(boolean result) {
+        this.result = result;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public int getPageNo() {
+        return pageNo;
+    }
+
+    public void setPageNo(int pageNo) {
+        this.pageNo = pageNo;
+    }
+
+    public int getPageSize() {
+        return pageSize;
+    }
+
+    public void setPageSize(int pageSize) {
+        this.pageSize = pageSize;
+    }
+
+    public long getCount() {
+        return count;
+    }
+
+    public void setCount(long count) {
+        this.count = count;
+    }
+
+    public List<CheckRecordData> getList() {
+        return list;
+    }
+
+    public void setList(List<CheckRecordData> list) {
+        this.list = list;
+    }
+}

src/com/mes/ui/DataUtil.java

@@ -0,0 +1,436 @@
+package com.mes.ui;
+
+import com.alibaba.fastjson2.JSONArray;
+import com.alibaba.fastjson2.JSONObject;
+import com.mes.util.JdbcUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+
+public class DataUtil {
+    public static final Logger log = LoggerFactory.getLogger(DataUtil.class);
+
+    //删除当前工位工件码
+    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;
+            JSONObject result = JSONObject.parseObject(doPost(url, params));
+//            log.info("请求参数："+params);
+            return result;
+        } catch (Exception e) {
+            log.info("e="+e.getMessage());
+            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;
+            JSONObject result = JSONObject.parseObject(doPost(url, params));
+//            log.info("请求参数："+params);
+            return result;
+        } catch (Exception e) {
+            log.info("e="+e.getMessage());
+            return null;
+        }
+    }
+
+    public static JSONObject checkQuality(String sn, String user){
+        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();
+            return checkQuality(sn, user, oprno, lineSn, mes_server_ip);
+        }catch (Exception e){
+            log.info("e="+e.getMessage());
+            return null;
+        }
+    }
+
+    public static JSONObject checkQuality(String sn, String user, String oprno, String lineSn, String serverIp){
+        try{
+            String url = "http://"+serverIp+":8980/js/a/mes/mesProductRecord/pccheck";
+            String params = "__ajax=json&oprno="+oprno+"&lineSn="+lineSn+"&sn="+sn+"&ucode="+user+"&__sid="+MesClient.sessionid;
+            log.info("params="+params);
+            String result = doPost(url,params);
+            log.info("result="+result);
+            if(result.equalsIgnoreCase("false")) {
+                return null;
+            }else {
+                JdbcUtils.insertData(oprno, "100000", params, "AQDW", sn);
+                return JSONObject.parseObject(result);
+            }
+        }catch (Exception e){
+            log.info("e="+e.getMessage());
+            return null;
+        }
+    }
+
+    public static JSONObject sendQuality(String sn,String ret,String user){
+        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();
+            return sendQuality(sn, ret, user, oprno, lineSn, mes_server_ip);
+        }catch (Exception e){
+            log.info("e="+e.getMessage());
+            return null;
+        }
+    }
+
+    public static JSONObject sendQuality(String sn, String ret, String user, String oprno, String lineSn, String serverIp){
+        try{
+            String url = "http://"+serverIp+":8980/js/a/mes/mesProductRecord/pcresult";
+            String params = "__ajax=json&oprno="+oprno+"&lineSn="+lineSn+"&sn="+sn+"&result="+ret+"&ucode="+user+"&__sid="+MesClient.sessionid;
+            log.info("params="+params);
+            String result = doPost(url,params);
+            log.info("result="+result);
+            System.out.println("请求参数"+params);
+            if(result.equalsIgnoreCase("false")) {
+                return null;
+            }else {
+                JdbcUtils.insertData(oprno, "100000", params, "MQDW", sn);
+                return JSONObject.parseObject(result);
+            }
+        }catch (Exception e){
+            log.info("e="+e.getMessage());
+            return null;
+        }
+    }
+
+    // 保存 PLC 读取到的点焊/焊接参数，复用后端 mesProductArcWelding/batchsave 接口。
+    public static JSONObject saveWeldingParams(String sn, String oprno, String lineSn, String serverIp, String content) {
+        try {
+            if (content == null || content.trim().isEmpty()) {
+                log.info("焊接参数为空，不上传，工位=" + oprno + "，工件码=" + sn);
+                return null;
+            }
+
+            String url = "http://" + serverIp + ":8980/js/a/mes/mesProductArcWelding/batchsave";
+            JSONArray paramsArray = new JSONArray();
+            JSONObject item = new JSONObject();
+            item.put("sn", sn);
+            item.put("oprno", oprno);
+            item.put("lineSn", lineSn);
+            item.put("content", content);
+            paramsArray.add(item);
+
+            String params = "__ajax=json&__sid=" + urlEncode(MesClient.sessionid)
+                    + "&params=" + urlEncode(paramsArray.toJSONString());
+            log.info("上传焊接参数：" + paramsArray.toJSONString());
+            String result = doPost(url, params);
+            log.info("上传焊接参数结果：" + result);
+            if (result == null || result.equalsIgnoreCase("false")) {
+                return null;
+            }
+            return JSONObject.parseObject(result);
+        } catch (Exception e) {
+            log.info("上传焊接参数异常：" + e.getMessage());
+            return null;
+        }
+    }
+
+    private static String urlEncode(String value) throws UnsupportedEncodingException {
+        return URLEncoder.encode(value == null ? "" : value, "UTF-8");
+    }
+
+    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 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");
+            connection.setRequestProperty("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
+            os = connection.getOutputStream();
+            os.write(param.getBytes());
+            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;
+    }
+
+    /**
+     * 查询工作记录
+     * @param oprno 工位号（空则查所有工位）
+     * @param sn 工件码（可选，用于搜索）
+     * @param pageNo 页码
+     * @param pageSize 每页条数
+     * @return 工作记录响应
+     */
+    public static WorkRecordResp getWorkRecordList(String oprno, String sn, int pageNo, int pageSize) {
+        WorkRecordResp resp = new WorkRecordResp();
+        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 lineSn = pro.getProperty("mes.line_sn").trim();
+            
+            String url = "http://" + mes_server_ip + ":8980/js/a/mes/mesProductRecord/ ";
+            StringBuilder params = new StringBuilder();
+            params.append("__ajax=json");
+            params.append("&lineSn=").append(lineSn);
+            params.append("&pageNo=").append(pageNo);
+            params.append("&pageSize=").append(pageSize);
+            
+            if (oprno != null && !oprno.isEmpty()) {
+                params.append("&oprno=").append(oprno);
+            }
+            // 注意：不传auto参数，这样"所有工位"查询时会返回整条产线所有工位的数据
+            if (sn != null && !sn.isEmpty()) {
+                params.append("&sn=").append(sn);
+            }
+            
+            log.info("查询工作记录: url=" + url + ", params=" + params.toString());
+            String result = doPost(url, params.toString());
+            log.info("查询工作记录结果: result=" + result);
+            
+            if (result == null || result.trim().isEmpty()) {
+                resp.setResult(false);
+                resp.setMessage("请求返回空结果");
+                return resp;
+            }
+            
+            JSONObject jsonObj = JSONObject.parseObject(result);
+            if (jsonObj == null) {
+                resp.setResult(false);
+                resp.setMessage("解析响应失败");
+                return resp;
+            }
+            
+            resp.setResult(true);
+            resp.setPageNo(jsonObj.getIntValue("pageNo"));
+            resp.setPageSize(jsonObj.getIntValue("pageSize"));
+            resp.setCount(jsonObj.getLongValue("count"));
+            
+            List<WorkRecordData> list = new ArrayList<>();
+            JSONArray listArray = jsonObj.getJSONArray("list");
+            if (listArray != null) {
+                for (int i = 0; i < listArray.size(); i++) {
+                    JSONObject item = listArray.getJSONObject(i);
+                    WorkRecordData data = new WorkRecordData();
+                    data.setId(item.getString("id"));
+                    data.setSn(item.getString("sn"));
+                    data.setOprno(item.getString("oprno"));
+                    data.setUpdateBy(item.getString("updateBy"));
+                    data.setUpdateDate(item.getString("updateDate"));
+                    data.setContent(item.getString("content"));
+                    list.add(data);
+                }
+            }
+            resp.setList(list);
+            
+        } catch (Exception e) {
+            log.error("查询工作记录异常: " + e.getMessage());
+            e.printStackTrace();
+            resp.setResult(false);
+            resp.setMessage("查询异常: " + e.getMessage());
+        }
+        return resp;
+    }
+
+    /**
+     * 查询点检记录
+     * @param oprno 工位号
+     * @param pageNo 页码
+     * @param pageSize 每页条数
+     * @return 点检记录响应
+     */
+    public static CheckRecordResp getCheckRecordList(String oprno, int pageNo, int pageSize) {
+        CheckRecordResp resp = new CheckRecordResp();
+        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 lineSn = pro.getProperty("mes.line_sn").trim();
+            
+            String url = "http://" + mes_server_ip + ":8980/js/a/mes/mesCheckRecord/list";
+            StringBuilder params = new StringBuilder();
+            params.append("__ajax=json");
+            params.append("&lineSn=").append(lineSn);
+            params.append("&oprno=").append(oprno);
+            params.append("&pageNo=").append(pageNo);
+            params.append("&pageSize=").append(pageSize);
+            
+            log.info("查询点检记录: url=" + url + ", params=" + params.toString());
+            String result = doPost(url, params.toString());
+            log.info("查询点检记录结果: result=" + result);
+            
+            if (result == null || result.trim().isEmpty()) {
+                resp.setResult(false);
+                resp.setMessage("请求返回空结果");
+                return resp;
+            }
+            
+            JSONObject jsonObj = JSONObject.parseObject(result);
+            if (jsonObj == null) {
+                resp.setResult(false);
+                resp.setMessage("解析响应失败");
+                return resp;
+            }
+            
+            resp.setResult(true);
+            resp.setPageNo(jsonObj.getIntValue("pageNo"));
+            resp.setPageSize(jsonObj.getIntValue("pageSize"));
+            resp.setCount(jsonObj.getLongValue("count"));
+            
+            List<CheckRecordData> list = new ArrayList<>();
+            JSONArray listArray = jsonObj.getJSONArray("list");
+            if (listArray != null) {
+                for (int i = 0; i < listArray.size(); i++) {
+                    JSONObject item = listArray.getJSONObject(i);
+                    CheckRecordData data = new CheckRecordData();
+                    data.setId(item.getString("id"));
+                    data.setCheckItem(item.getString("checkItem"));
+                    data.setCheckResult(item.getString("checkResult"));
+                    data.setUpdateBy(item.getString("updateBy"));
+                    data.setUpdateDate(item.getString("updateDate"));
+                    list.add(data);
+                }
+            }
+            resp.setList(list);
+            
+        } catch (Exception e) {
+            log.error("查询点检记录异常: " + e.getMessage());
+            e.printStackTrace();
+            resp.setResult(false);
+            resp.setMessage("查询异常: " + e.getMessage());
+        }
+        return resp;
+    }
+}

src/com/mes/ui/LockUtil.java

@@ -0,0 +1,85 @@
+package com.mes.ui;
+
+import java.io.File;
+import java.io.RandomAccessFile;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.channels.OverlappingFileLockException;
+
+public class LockUtil {
+    private FileChannel channel;
+
+    private FileLock lock;
+
+    private File file;
+
+    private static LockUtil instance = null;
+
+    /**
+     * 获取唯一进程限制的实例
+     * @Title: getInstance
+     * @return  唯一进程实例
+     */
+    public static LockUtil getInstance(){
+        if(instance == null){
+            instance = new LockUtil();
+        }
+        return instance;
+    }
+
+    /**
+     * 进程是否正在运行
+     * @Title: isAppActive
+     * @return  运行与否
+     */
+    public boolean isAppActive() {
+        File file = new File(".lock");
+        try {
+            channel = new RandomAccessFile(file, "rw").getChannel();
+            try {
+                lock = channel.tryLock();
+
+            } catch (OverlappingFileLockException e) {
+                closeLock();
+                return true;
+            }
+            if (lock == null) {
+                closeLock();
+                return true;
+            }
+            Runtime.getRuntime().addShutdownHook(new Thread() {
+                public void run() {
+                    closeLock();
+                    deleteFile();
+                }
+            });
+            return false;
+        } catch (Exception e) {
+            closeLock();
+            return true;
+        }
+    }
+
+    protected void deleteFile() {
+        try {
+            file.delete();
+        } catch (Exception e) {
+
+        }
+
+    }
+
+    private void closeLock() {
+        try {
+            lock.release();
+        } catch (Exception e) {
+
+        }
+
+        try {
+            channel.close();
+        } catch (Exception e) {
+
+        }
+    }
+}

src/com/mes/ui/LoginFarme.java

@@ -0,0 +1,207 @@
+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.time.LocalDateTime;
+
+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系统客户端："+"工作站1");
+
+        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("system");
+        userNameTxt.setBounds(400, 105, 150, 30);
+        userPasswordTxt = new JPasswordField(20);
+        userPasswordTxt.setBounds(400, 155, 150, 30);
+        userPasswordTxt.setText("Aa111111");
+        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 = Base64Utils.getBase64(user_str);
+        String password = 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="+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="+MesClient.sessionid+"&oprno="+MesClient.mes_gw+"&lineSn="+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) {
+                    // 获取等于所处时间-当前小时
+                    LocalDateTime now = LocalDateTime.now();
+                    MesClient.userLoginHours = now.getHour();
+                    //登录成功
+                    MultiStationClient.welcomeWin.setVisible(false);
+                    MultiStationClient.mainFrame.setUser(user_id);
+                    MultiStationClient.mainFrame.setVisible(true);
+//                    MesClient.mesClientFrame.setVisible(true);
+
+                    // 获取工作记录
+                    if(MultiStationClient.workRecordPanel == null){
+                        String url = "http://"+ MesClient.mes_server_ip+":8980/js/a/mes/mesProductRecord/work?oprno="+MesClient.mes_gw+"&lineSn="+MesClient.mes_line_sn;
+                        MultiStationClient.workRecordPanel = new MesWebView(url);
+                        MultiStationClient.workRecordPanel.setSize(990, 550);
+                        MultiStationClient.indexPaneWork.add(MultiStationClient.workRecordPanel);
+                    }
+
+                    // 获取点检记录
+                    if(MultiStationClient.checkPanel == null){
+                        String url = "http://"+ MesClient.mes_server_ip+":8980/js/a/mes/mesProcessCheckRecord/ulist?ucode="+user_id+"&oprno="+MesClient.mes_gw+"&lineSn="+MesClient.mes_line_sn;
+                        MultiStationClient.checkPanel = new MesWebView(url);
+                        MultiStationClient.checkPanel.setSize(990, 550);
+                        MultiStationClient.indexPaneCheck.add(MultiStationClient.checkPanel);
+                    }
+
+//                    MesClient.initWarehouseData();
+                }
+
+            }
+
+        }else {
+            JOptionPane.showMessageDialog(MesClient.mesClientFrame,"登录失败,用户名或密码错误","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+            return;
+        }
+    }
+}

src/com/mes/ui/MesClient.java

@@ -0,0 +1,779 @@
+package com.mes.ui;
+
+import com.alibaba.fastjson2.JSONObject;
+import com.mes.component.MesRadio;
+import com.mes.component.MesWebView;
+import com.mes.util.DateLocalUtils;
+import com.mes.util.HttpUtils;
+import com.mes.util.JdbcUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.swing.*;
+import javax.swing.border.EmptyBorder;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+import java.awt.event.*;
+import java.io.*;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Properties;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class MesClient extends JFrame {
+    public static final Logger log = LoggerFactory.getLogger(MesClient.class);
+
+    public static int mes_auth = 0; // 权限级别 0=无权限 1=操作工人 2=管理员
+    public static String mes_gw = ""; // 工位号
+    public static String mes_gw_des = ""; // 工位名称
+    public static String mes_server_ip = ""; // 服务器IP地址
+    public static int mes_heart_icon_cycle = 1;
+    public static String mes_line_sn = ""; // 产线编号
+
+    //session
+    public static String sessionid = "";
+
+    public static JPanel contentPane;
+    public static MesClient mesClientFrame;
+    public static MultiStationClient multiStationClientFrame;
+    public static JTabbedPane tabbedPane;
+    public static JScrollPane indexScrollPaneA;
+    public static JScrollPane searchScrollPane; // 已弃用，改为使用 WorkRecordPanel
+    public static JScrollPane searchScrollPaneDj;
+
+
+    public static Boolean check_quality_result = false;
+    public static Integer work_status = 0;
+
+    public static JButton heart_beat_menu;
+    public static JButton status_menu;
+    public static JButton user_menu;
+
+    public static int scan_type = 0;
+    public static JButton finish_ok_bt;
+    public static JButton finish_ng_bt;
+    public static JTextField product_sn;
+    public static JButton f_scan_data_bt_1;
+
+    public static String user20 = "";
+
+    public static JFrame welcomeWin;
+
+    public static JPanel indexPanelB; // 已弃用，改为使用 WorkRecordPanel
+    public static MesWebView jfxPanel = null;
+    public static JPanel indexPanelC;
+    public static MesWebView jfxPanel2 = null;
+    public static MesRadio mesRadioHj;
+
+    public static JTable table;
+    public static Object[] columnNames = { "物料名称", "绑定批次", "剩余次数", "操作" };
+    public static Object[][] rowData = null;
+
+    public static JLabel fxlabel;
+
+//    public static void main(String[] args) {
+//
+//        if (LockUtil.getInstance().isAppActive() == true){
+////            JOptionPane.showMessageDialog(null, "已有一个程序在运行,程序退出");
+//            return;
+//        }else{
+//            EventQueue.invokeLater(new Runnable() {
+//                @Override
+//                public void run() {
+//                    try{
+//                        //读文件配置
+//                        readProperty();
+//
+//                        // 显示界面
+//                        mesClientFrame = new MesClient();
+//                        multiStationClientFrame = new MultiStationClient();
+//                        multiStationClientFrame.setVisible(false);
+//
+//                        JdbcUtils.getConn();
+//
+//                        welcomeWin = new LoginFarme();
+//                        welcomeWin.setVisible(true);
+//
+//                        getMaterailData();
+//
+//                    }catch (Exception e){
+//                        e.printStackTrace();
+//                    }
+//                }
+//            });
+//        }
+//    }
+
+    //读配置文件
+    public static void readProperty() throws IOException{
+        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);
+        mes_gw =  pro.getProperty("mes.gw");
+        mes_server_ip = pro.getProperty("mes.server_ip");
+        mes_line_sn = pro.getProperty("mes.line_sn");
+        mes_gw_des = OprnoUtil.getGwDes(mes_line_sn,mes_gw);
+        log.info(mes_gw + ";" + mes_gw_des + ";" + mes_server_ip + ";");
+    }
+
+    //启动心跳包程序
+    public static java.util.Timer heartBeatTimer;
+    public static java.util.Timer heartBeatIconTimer;
+    public static boolean iconREDFlag = true;
+    public static void startHeartBeatTimer() {
+        if(heartBeatTimer!=null) {
+            heartBeatTimer.cancel();
+        }
+
+        //心跳显示图标
+        if(heartBeatIconTimer!=null) {
+            heartBeatIconTimer.cancel();
+        }
+        heartBeatIconTimer = new Timer();
+        heartBeatIconTimer.schedule(new TimerTask() {
+            public void run() {
+                if(iconREDFlag) {
+                    heart_beat_menu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/grey_dot.png")));
+                    iconREDFlag = false;
+                }else {
+                    heart_beat_menu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/green_dot.png")));
+                    iconREDFlag = true;
+                }
+                heart_beat_menu.setText(DateLocalUtils.getCurrentTime());
+                heart_beat_menu.repaint();
+            }
+        }, 100,mes_heart_icon_cycle*1000);
+    }
+
+    //设置tcp连接状态显示
+    public static void setTcpStatus() {
+        status_menu.setText("已连接MES服务器");
+        heart_beat_menu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/grey_dot.png")));
+        heart_beat_menu.repaint();
+    }
+
+    public static void initWarehouseData(){
+        resetScanA();
+    }
+
+    public static void resetScanA() {
+        work_status = 0;
+        check_quality_result = false;
+        MesClient.finish_ok_bt.setEnabled(false);
+        MesClient.finish_ng_bt.setEnabled(false);
+        product_sn.setText("");
+        MesClient.fxlabel.setVisible(false);
+
+        MesClient.f_scan_data_bt_1.setEnabled(true);
+        MesClient.setMenuStatus("请扫工件码",0);
+//        MesClient.setMenuStatus("开班点检，请先进行OKNG样件测试",-1);
+
+        updateMaterailData();
+//        shiftUserCheck();
+    }
+
+    public static int userLoginHours;//用户登录所处小时
+    //换班用户信息检查
+    private static  void  shiftUserCheck() {
+        LocalDateTime now = LocalDateTime.now();
+        // 判断时间范围
+        if (userLoginHours >= 8 && userLoginHours < 20) {
+
+            int hour = now.getHour();
+            if (hour >= 20 || hour < 8) {
+                logoff();
+            }
+        } else {
+            int hour = now.getHour();
+            if (hour >= 8 && hour < 20) {
+                logoff();
+            }
+        }
+    }
+    public static void resetScanB() {
+
+    }
+
+    //获取用户20位
+    public static void getUser() {
+        user20 = user_menu.getText().toString();
+//        String space_tmp1 = "";
+//        if(user20.length()<20) {
+//            for(int i=0;i<20-user20.length();i++) {
+//                space_tmp1 = space_tmp1 + " ";
+//            }
+//        }
+//        user20 = user20 + space_tmp1;
+    }
+
+    //获取barcode内容36位
+    public static String getBarcode(String barcodeTmp) {
+        String barcodeRet = barcodeTmp;
+        if(barcodeTmp.equalsIgnoreCase("")) {
+            return "";
+        }else {
+            if(barcodeTmp.length()<36) {
+                String space = "";
+                for(int i=0;i<36-barcodeTmp.length();i++) {
+                    space = space + " ";
+                }
+                barcodeRet = barcodeTmp + space;
+            }
+        }
+        return barcodeRet;
+    }
+
+    public static void scanBarcode() {
+        if(work_status == 1){
+            JOptionPane.showMessageDialog(mesClientFrame,"工作中，勿扫码","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+            return;
+        }
+        String scanBarcodeTitle = "";
+        switch(scan_type) {
+            case 1:
+                product_sn.setText("");
+                scanBarcodeTitle = "请扫工件码";
+                break;
+        }
+
+        //弹窗扫工件码
+        String scanBarcode = JOptionPane.showInputDialog(null, scanBarcodeTitle);
+        if(scanBarcode!=null&&!scanBarcode.equalsIgnoreCase("")) {
+            //获取用户
+            getUser();
+            //获取扫码内容36位
+            String barcode36 = getBarcode(scanBarcode);//处理36为码
+            //工位号
+            String gw = "";
+            switch(scan_type) {
+                case 1:
+                    product_sn.setText(scanBarcode);
+                    break;
+            }
+            //刷新界面
+            mesClientFrame.repaint();
+
+            // 查询工件质量
+            JSONObject retObj = DataUtil.checkQuality(scanBarcode,user20);
+            if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
+                MesClient.status_menu.setForeground(Color.GREEN);
+                MesClient.check_quality_result = true;//质量合格，可以绑定加工
+                MesClient.status_menu.setText("该工件可以加工");
+                MesClient.work_status = 1;
+                MesClient.f_scan_data_bt_1.setEnabled(false);
+                MesClient.finish_ok_bt.setEnabled(true);
+                MesClient.finish_ng_bt.setEnabled(true);
+            }else{
+                MesClient.check_quality_result = false;
+                MesClient.work_status = 0;
+                if(retObj.get("result")==null){
+                    MesClient.setMenuStatus("请求失败，请重试",-1);
+                }else{
+                    if(retObj.get("result").toString().equalsIgnoreCase("false")){
+                        MesClient.setMenuStatus(retObj.getString("message"),-1);
+                    }
+                }
+            }
+        }else {
+            MesClient.setMenuStatus("请扫工件码，请重试",-1);
+//            JOptionPane.showMessageDialog(mesClientFrame,"请扫工件码","提示窗口", JOptionPane.INFORMATION_MESSAGE);
+            return;
+        }
+    }
+
+    public static void logoff() {
+        welcomeWin.setVisible(true);
+        mesClientFrame.setVisible(false);
+    }
+
+    public MesClient() {
+        setIconImage(Toolkit.getDefaultToolkit().getImage(MesClient.class.getResource("/bg/logo.png")));
+        setTitle("MES系统客户端："+mes_gw + "- " + mes_gw_des);
+//        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setBounds(0, 0, 1024, 768);
+
+        setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
+        // 添加窗口监听器
+        addWindowListener(new WindowAdapter() {
+            @Override
+            public void windowClosing(WindowEvent e) {
+                int choice = JOptionPane.showConfirmDialog(null, "确定要关闭窗口吗？", "关闭确认", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
+                if (choice == JOptionPane.YES_OPTION) {
+                    // 如果用户点击“是”，则关闭窗口
+                    dispose(); // 释放窗口资源并关闭窗口
+                    System.exit(0);
+                }
+            }
+        });
+
+        JMenuBar menuBar = new JMenuBar();
+        menuBar.setFont(new Font("Microsoft YaHei UI", Font.PLAIN, 26));
+        setJMenuBar(menuBar);
+        JMenu fileMenu = new JMenu("用户");
+        fileMenu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/user.png")));
+        fileMenu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        menuBar.add(fileMenu);
+
+        JMenuItem exitMenuItem = new JMenuItem("退出");
+        exitMenuItem.setIcon(new ImageIcon(MesClient.class.getResource("/bg/logoff.png")));
+        exitMenuItem.setFont(new Font("微软雅黑", Font.PLAIN, 22));
+        fileMenu.add(exitMenuItem);
+        exitMenuItem.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {//只能检测到mousePressed事件
+                super.mouseClicked(e);
+                //dispose();
+                logoff();
+            }
+        });
+
+        JMenu settingMenu = new JMenu("设置");
+        //settingMenu.setVisible(false);
+        settingMenu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/menu_setting.png")));
+        settingMenu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        menuBar.add(settingMenu);
+
+        JMenuItem resetTcpMenu = new JMenuItem("\u91CD\u8FDEMES");
+        resetTcpMenu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/reset_logo.png")));
+        resetTcpMenu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        resetTcpMenu.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {
+                super.mouseClicked(e);
+            }
+        });
+//        settingMenu.add(resetTcpMenu);
+
+        JMenuItem resetTcpMenu_1 = new JMenuItem("刷新工件");
+        resetTcpMenu_1.setIcon(new ImageIcon(MesClient.class.getResource("/bg/reset_logo.png")));
+        resetTcpMenu_1.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        resetTcpMenu_1.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {
+                super.mouseClicked(e);
+                resetScanA();
+            }
+        });
+        settingMenu.add(resetTcpMenu_1);
+
+        contentPane = new JPanel();
+        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
+        setContentPane(contentPane);
+        contentPane.setLayout(new BorderLayout(0, 0));
+
+        JToolBar toolBar = new JToolBar();
+        contentPane.add(toolBar, BorderLayout.NORTH);
+
+        JLabel equipment_statu_label = new JLabel("状态：");
+        equipment_statu_label.setHorizontalAlignment(SwingConstants.CENTER);
+        equipment_statu_label.setForeground(Color.BLACK);
+        equipment_statu_label.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        equipment_statu_label.setBackground(Color.LIGHT_GRAY);
+        toolBar.add(equipment_statu_label);
+
+        status_menu = new JButton("设备未连接MES服务器");
+        status_menu.setText("已连接MES服务器");
+        status_menu.setForeground(Color.GREEN);
+        status_menu.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+            }
+        });
+        status_menu.setForeground(Color.GREEN);
+        status_menu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        status_menu.setBackground(Color.BLACK);
+        toolBar.add(status_menu);
+
+        JLabel space_1 = new JLabel("    ");
+        toolBar.add(space_1);
+
+        JLabel heart_beat_status_label = new JLabel("心跳：");
+        heart_beat_status_label.setHorizontalAlignment(SwingConstants.CENTER);
+        heart_beat_status_label.setForeground(Color.BLACK);
+        heart_beat_status_label.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        heart_beat_status_label.setBackground(Color.LIGHT_GRAY);
+        toolBar.add(heart_beat_status_label);
+
+        heart_beat_menu = new JButton("2024-02-20 23:20:10");
+        heart_beat_menu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/green_dot.png")));
+        heart_beat_menu.setForeground(Color.GREEN);
+        heart_beat_menu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        heart_beat_menu.setBackground(Color.BLACK);
+        toolBar.add(heart_beat_menu);
+
+        JLabel space_2 = new JLabel("    ");
+        toolBar.add(space_2);
+
+        JLabel user_status_label = new JLabel("登录用户：");
+        user_status_label.setHorizontalAlignment(SwingConstants.CENTER);
+        user_status_label.setForeground(Color.BLACK);
+        user_status_label.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        user_status_label.setBackground(Color.LIGHT_GRAY);
+        toolBar.add(user_status_label);
+
+        user_menu = new JButton("JinJuShi");
+        user_menu.setForeground(Color.GREEN);
+        user_menu.setFont(new Font("微软雅黑", Font.PLAIN, 22));
+        user_menu.setBackground(Color.BLACK);
+        toolBar.add(user_menu);
+
+        JLabel space_3 = new JLabel("    ");
+        toolBar.add(space_3);
+
+        JLabel space_4 = new JLabel("    ");
+        toolBar.add(space_4);
+
+        tabbedPane = new JTabbedPane(JTabbedPane.TOP);
+        tabbedPane.setMinimumSize(new Dimension(400, 50));
+        tabbedPane.setFont(new Font("宋体", Font.BOLD, 22));
+        contentPane.add(tabbedPane);
+
+        //首页
+        JPanel indexPanelA = new JPanel();
+        indexScrollPaneA = new JScrollPane(indexPanelA);
+        indexPanelA.setLayout(null);
+
+        product_sn = new JTextField();
+        product_sn.setHorizontalAlignment(SwingConstants.CENTER);
+        product_sn.setEditable(false);
+        product_sn.setFont(new Font("微软雅黑", Font.PLAIN, 28));
+        product_sn.setBounds(81, 70, 602, 70);
+        indexPanelA.add(product_sn);
+        product_sn.setColumns(10);
+
+        f_scan_data_bt_1 = new JButton("扫码");
+        f_scan_data_bt_1.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                scan_type = 1;
+                scanBarcode();
+            }
+        });
+        f_scan_data_bt_1.setIcon(new ImageIcon(MesClient.class.getResource("/bg/scan_barcode.png")));
+        f_scan_data_bt_1.setFont(new Font("微软雅黑", Font.PLAIN, 32));
+        f_scan_data_bt_1.setBounds(693, 70, 198, 70);
+        indexPanelA.add(f_scan_data_bt_1);
+
+//        String[] hjtitles = new String[]{"焊机1","焊机2","焊机3"};
+//        String[] hjvals = new String[]{"HJ001","HJ002","HJ003"};
+//        mesRadioHj = new MesRadio(hjtitles,hjvals);
+//        mesRadioHj.setSize(500,50);
+//        mesRadioHj.setBounds(190,170,500,50);
+//        indexPanelA.add(mesRadioHj);
+
+        fxlabel = new JLabel("该工件为返修件，请仔细检查");
+        fxlabel.setFont(new Font("微软雅黑", Font.PLAIN, 38));
+        fxlabel.setBounds(81, 170, 810, 70);
+        fxlabel.setForeground(Color.RED);
+        fxlabel.setHorizontalAlignment(SwingConstants.CENTER);
+        fxlabel.setVisible(false);
+        indexPanelA.add(fxlabel);
+
+        finish_ok_bt = new JButton("OK");
+        finish_ok_bt.setEnabled(false);
+        finish_ok_bt.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                if(work_status == 1 && check_quality_result){
+                    getUser();
+                    String sn = MesClient.product_sn.getText().trim();
+                    if(sn.isEmpty()){
+                        MesClient.setMenuStatus("工件码为空，请重试",-1);
+                        return;
+                    }
+
+                    JSONObject retObj = DataUtil.sendQuality(sn,"OK",user20);
+                    System.out.println(retObj);
+                    if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
+                        MesClient.resetScanA();
+                        MesClient.setMenuStatus("结果提交成功，请扫下一件",0);
+                        MesClient.scan_type = 1;
+                        MesClient.scanBarcode();
+                    }else{
+                        if(retObj.get("result")==null){
+                            MesClient.setMenuStatus("请求失败，请重试",-1);
+                        }else{
+                            if(retObj.get("result").toString().equalsIgnoreCase("false")){
+                                MesClient.setMenuStatus(retObj.getString("message"),-1);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        finish_ok_bt.setIcon(new ImageIcon(MesClient.class.getResource("/bg/ok_bg.png")));
+        finish_ok_bt.setFont(new Font("微软雅黑", Font.PLAIN, 32));
+        finish_ok_bt.setBounds(185, 291, 240, 80);
+        finish_ok_bt.setEnabled(false);
+        indexPanelA.add(finish_ok_bt);
+
+        finish_ng_bt = new JButton("NG");
+        finish_ng_bt.setEnabled(false);
+        finish_ng_bt.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                if(work_status == 1 && check_quality_result){
+                    getUser();
+                    String sn = MesClient.product_sn.getText().trim();
+                    if(sn.isEmpty()){
+                        MesClient.setMenuStatus("工件码为空，请重试",-1);
+                        return;
+                    }
+
+                    JSONObject retObj = DataUtil.sendQuality(sn,"NG",user20);
+                    if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
+                        MesClient.resetScanA();
+                        MesClient.setMenuStatus("结果提交成功，请扫下一件",0);
+                        MesClient.scan_type = 1;
+                        MesClient.scanBarcode();
+                    }else{
+                        if(retObj.get("result")==null){
+                            MesClient.setMenuStatus("请求失败，请重试",-1);
+                        }else{
+                            if(retObj.get("result").toString().equalsIgnoreCase("false")){
+                                MesClient.setMenuStatus(retObj.getString("message"),-1);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        finish_ng_bt.setIcon(new ImageIcon(MesClient.class.getResource("/bg/ng_bg.png")));
+        finish_ng_bt.setFont(new Font("微软雅黑", Font.PLAIN, 32));
+        finish_ng_bt.setBounds(508, 291, 240, 80);
+        finish_ng_bt.setEnabled(false);
+        indexPanelA.add(finish_ng_bt);
+
+        tabbedPane.addTab("工作面板", new ImageIcon(MesClient.class.getResource("/bg/a_side.png")), indexScrollPaneA, null);
+        tabbedPane.setEnabledAt(0, true);
+
+//		searchScrollPane = new JScrollPane((Component) null);
+
+        indexPanelC = new JPanel();
+        searchScrollPaneDj = new JScrollPane(indexPanelC);
+        indexPanelC.setLayout(null);
+
+        tabbedPane.addTab("开班点检", new ImageIcon(MesClient.class.getResource("/bg/menu_data_preprocess.png")), searchScrollPaneDj, null);
+
+
+        // ========== 工作记录 Tab（改造：当前工位Tab + 所有工位Tab） ==========
+        // 旧代码已注释:
+         indexPanelB = new JPanel();
+         searchScrollPane = new JScrollPane(indexPanelB);
+         indexPanelB.setLayout(null);
+         tabbedPane.addTab("工作记录", new ImageIcon(MesClient.class.getResource("/bg/menu_data_preprocess.png")), searchScrollPane, null);
+
+//        // 创建工作记录的子 TabbedPane
+//        JTabbedPane workRecordTabbedPane = new JTabbedPane(JTabbedPane.TOP);
+//        workRecordTabbedPane.setFont(new Font("微软雅黑", Font.PLAIN, 14));
+//
+//        // OKNG 工位：当前工位 + 所有工位
+//        WorkRecordPanel[] workRecordPanels = new WorkRecordPanel[2];
+//
+//        // 当前工位Tab（使用配置文件中的 mes.gw）
+//        workRecordPanels[0] = new WorkRecordPanel(mes_gw, mes_line_sn);
+//        workRecordTabbedPane.addTab(mes_gw, null, workRecordPanels[0], "查询" + mes_gw + "的工作记录");
+//
+//        // 所有工位Tab（查询整条产线所有工位）
+//        workRecordPanels[1] = new WorkRecordPanel(null, mes_line_sn);
+//        workRecordTabbedPane.addTab("所有工位", null, workRecordPanels[1], "查询整条产线所有工位的工作记录");
+//
+//        // 切换子Tab时自动刷新数据
+//        workRecordTabbedPane.addChangeListener(e -> {
+//            int selectedIndex = workRecordTabbedPane.getSelectedIndex();
+//            if (selectedIndex >= 0 && selectedIndex < workRecordPanels.length) {
+//                workRecordPanels[selectedIndex].refreshData();
+//            }
+//        });
+//
+//        // 将子 TabbedPane 添加到主 TabbedPane
+//        tabbedPane.addTab("工作记录", new ImageIcon(MesClient.class.getResource("/bg/menu_data_preprocess.png")), workRecordTabbedPane, null);
+//
+
+		tabbedPane.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                JTabbedPane tabbedPane = (JTabbedPane) e.getSource();
+                int selectedIndex = tabbedPane.getSelectedIndex();
+                System.out.println("selectedIndex:"+selectedIndex);
+
+                if(selectedIndex == 1){
+
+                }
+            }
+        });
+    }
+
+    public static void setMenuStatus(String msg,int error){
+        if(error == 0){
+            MesClient.status_menu.setForeground(Color.GREEN);
+        }else{
+            MesClient.status_menu.setForeground(Color.RED);
+        }
+        MesClient.status_menu.setText(msg);
+    }
+
+    public static void getMaterailData(){
+        try{
+            JSONObject retObj = DataUtil.getBindMaterail();
+            if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
+                java.util.List<BindMaterialResp> arrs = retObj.getList("data",BindMaterialResp.class);
+                int i = 0;
+                rowData = new Object[arrs.size()][7];
+                for (BindMaterialResp bindMaterialResp:arrs){
+                    rowData[i][0] = bindMaterialResp.getMaterialTitle();
+                    rowData[i][1] = bindMaterialResp.getBatchSn();
+                    rowData[i][2] = bindMaterialResp.getLastTimes();
+                    rowData[i][3] = "";
+                    rowData[i][4] = bindMaterialResp.getCraft();
+                    rowData[i][5] = bindMaterialResp.getMaterialId();
+                    rowData[i][6] = bindMaterialResp.getType();
+                    i++;
+                }
+                bindBatchPanel();
+            }
+        }catch (Exception e){
+            log.info(e.getMessage());
+        }
+    }
+
+    public static void updateMaterailData(){
+        try{
+            JSONObject retObj = DataUtil.getBindMaterail();
+            if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
+                List<BindMaterialResp> arrs = retObj.getList("data",BindMaterialResp.class);
+
+                int i = 0;
+                for (BindMaterialResp bindMaterialResp:arrs){
+                    rowData[i][0] = bindMaterialResp.getMaterialTitle();
+                    rowData[i][1] = bindMaterialResp.getBatchSn();
+                    rowData[i][2] = bindMaterialResp.getLastTimes();
+                    rowData[i][3] = "";
+                    rowData[i][4] = bindMaterialResp.getCraft();
+                    rowData[i][5] = bindMaterialResp.getMaterialId();
+                    rowData[i][6] = bindMaterialResp.getType();
+                    i++;
+                }
+
+                MesClient.table.repaint();
+            }
+        }catch (Exception e){
+            log.info(e.getMessage());
+        }
+    }
+
+    // 绑定物料批次码
+    public static void scanBatchSn(BindMaterialResp bindMaterialResp) {
+        //弹窗扫工件码
+        String scanBarcodeTitle = "请扫物料:"+bindMaterialResp.getMaterialTitle();
+        String scanBarcode = JOptionPane.showInputDialog(null, scanBarcodeTitle);
+        if(scanBarcode!=null&&!scanBarcode.equalsIgnoreCase("")) {
+
+            JSONObject retObj = DataUtil.saveBindMaterail(scanBarcode,bindMaterialResp.getCraft(),bindMaterialResp.getMaterialId(),bindMaterialResp.getType());
+            if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
+                MesClient.setMenuStatus("扫物料:"+bindMaterialResp.getMaterialTitle()+"成功",0);
+                updateMaterailData();
+            }else{
+                if(retObj.get("result")==null){
+                    MesClient.setMenuStatus("请求失败，请重试",-1);
+                }else{
+                    if(retObj.get("result").toString().equalsIgnoreCase("false")){
+                        MesClient.setMenuStatus(retObj.getString("message"),-1);
+                    }
+                }
+            }
+        }
+    }
+
+    public static void bindBatchPanel(){
+        JPanel indexPanelBB = new JPanel();
+        JPanel panel = new JPanel();
+        panel.setBounds(0, 0, 990, 550);
+//        panel.setBounds(81, 50, 810, 479);
+        indexPanelBB.add(panel);
+
+        panel.setLayout(new GridLayout(0, 1, 0, 0));
+        table = new JTable(rowData, columnNames){
+            public boolean isCellEditable(int row, int column) {
+                if(column == 3){
+                    return true;
+                }
+                return false;
+            }
+        };
+        table.setRowHeight(40);
+        table.setEnabled(true);
+        table.setFont(new Font("微软雅黑", Font.PLAIN, 14));
+
+        table.getColumnModel().getColumn(3).setCellRenderer(new TableCellRendererButton());
+        table.getColumnModel().getColumn(3).setCellEditor(new TableCellEditorButton());
+
+
+        JScrollPane scrollPane = new JScrollPane(table);
+        panel.add(scrollPane);
+
+        JScrollPane indexScrollPaneB = new JScrollPane(indexPanelBB);
+        indexPanelBB.setLayout(null);
+        tabbedPane.addTab("绑定物料", new ImageIcon(MesClient.class.getResource("/bg/menu_data_preprocess.png")), indexScrollPaneB, null);
+    }
+
+    // 开启发送结果定时任务
+    public static void startUpdateQualityTimer(){
+        // 创建异步线程池
+        ExecutorService executorService = Executors.newSingleThreadExecutor();
+        // 提交任务
+        executorService.submit(() -> {
+            log.info("异步任务执行中...");
+            // 模拟耗时操作
+            try {
+                while (true){
+                    try {
+                        // 确保连接已经打开
+                        if (JdbcUtils.conn == null || JdbcUtils.conn.isClosed()) {
+                            JdbcUtils.openConnection();
+                        }
+
+                        Statement statement = JdbcUtils.conn.createStatement();
+                        String selectSql = "SELECT id, bw FROM submit_record\n" +
+                                "WHERE state = 0 ORDER BY id DESC LIMIT 10";
+                        String updateSql = "UPDATE submit_record \n" +
+                                "SET state = '1'\n" +
+                                "WHERE id = ";
+                        ResultSet rs = statement.executeQuery(selectSql);
+                        while(rs.next()){
+                            int id = rs.getInt("id");
+                            String bw = rs.getString("bw");
+                            // 发送请求
+                            String url = "http://"+MesClient.mes_server_ip+":8980/js/a/mes/mesProductRecord/updateQualityByTiming";
+                            log.info("质量："+bw);
+                            String s = HttpUtils.sendPostRequestJson(url, bw );
+                            log.info("结果："+s);
+                            Boolean result = JSONObject.parseObject(s).getBoolean("result");
+                            if(result) {
+                                // 更改状态为 1
+                                statement.executeUpdate(updateSql + id);
+                            }
+                        }
+                        rs.close();
+                        statement.close();
+                    } catch (Exception e) {
+                        log.info(e.getMessage());
+                    }
+                    try {
+                        Thread.sleep(2000);
+                    }catch (Exception e){
+                        log.info(e.getMessage());
+                    }
+                }
+            } catch (Exception e) {
+                log.info(e.getMessage());
+            }
+            log.info("异步任务执行完毕");
+        });
+    }
+
+}

src/com/mes/ui/MultiStationClient.java

@@ -0,0 +1,278 @@
+package com.mes.ui;
+
+import com.alibaba.fastjson2.JSONObject;
+import com.mes.component.MesWebView;
+import com.mes.util.JdbcUtils;
+import com.mes.util.StationConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.mes.ui.MesClient.mes_server_ip;
+import static com.mes.ui.MesClient.resetScanA;
+import static com.mes.ui.WorkStationPanel.*;
+
+public class MultiStationClient extends JFrame {
+    private static final Logger log = LoggerFactory.getLogger(MultiStationClient.class);
+    private List<WorkStationPanel> stationPanels = new ArrayList<>();
+
+    private JButton userMenu;
+    private JLabel statusLabel;
+    private JLabel heartBeatLabel;
+    public static JFrame welcomeWin;
+    public static MultiStationClient mainFrame;
+
+    public static JScrollPane searchScrollPaneWork; // 已弃用，改为使用WebView
+    public static JScrollPane searchScrollPaneCheck;
+
+    public static JPanel indexPaneWork; // 已弃用，改为使用WebView
+    public static JPanel indexPaneCheck;
+
+    public static MesWebView workRecordPanel = null;
+    public static MesWebView checkPanel = null;
+
+
+    public static void main(String[] args) {
+        if (LockUtil.getInstance().isAppActive()) {
+            JOptionPane.showMessageDialog(null, "已有一个程序在运行，程序退出");
+            return;
+        }
+
+        EventQueue.invokeLater(() -> {
+            try {
+                MesClient.readProperty();
+                JdbcUtils.getConn();
+                welcomeWin = new LoginFarme();
+                welcomeWin.setVisible(true);
+                MultiStationClient frame = new MultiStationClient();
+                frame.setVisible(false);
+            } catch (Exception e) {
+                e.printStackTrace();
+                JOptionPane.showMessageDialog(null, "启动失败: " + e.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
+            }
+        });
+    }
+    
+    public MultiStationClient() {
+        mainFrame = this;
+        initUI();
+    }
+    
+    private void initUI() {
+        setTitle("MES系统客户端 - 多工位模式");
+        setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+        addWindowListener(new WindowAdapter() {
+            @Override
+            public void windowClosing(WindowEvent e) {
+                int choice = JOptionPane.showConfirmDialog(null, "确定要关闭窗口吗？", "关闭确认", 
+                    JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
+                if (choice == JOptionPane.YES_OPTION) {
+                    dispose();
+                    System.exit(0);
+                }
+            }
+        });
+        
+        setIconImage(Toolkit.getDefaultToolkit().getImage(getClass().getResource("/bg/logo.png")));
+        
+        JMenuBar menuBar = new JMenuBar();
+        setJMenuBar(menuBar);
+        
+        JMenu fileMenu = new JMenu("用户");
+        fileMenu.setIcon(new ImageIcon(getClass().getResource("/bg/user.png")));
+        fileMenu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        menuBar.add(fileMenu);
+        
+        JMenuItem exitMenuItem = new JMenuItem("退出");
+        exitMenuItem.setIcon(new ImageIcon(getClass().getResource("/bg/logoff.png")));
+        exitMenuItem.setFont(new Font("微软雅黑", Font.PLAIN, 18));
+        exitMenuItem.addActionListener(e -> {
+            int choice = JOptionPane.showConfirmDialog(null, "确定要退出吗？", "退出确认", 
+                JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
+            if (choice == JOptionPane.YES_OPTION) {
+                System.exit(0);
+            }
+        });
+        fileMenu.add(exitMenuItem);
+        
+        JMenu settingMenu = new JMenu("设置");
+        settingMenu.setIcon(new ImageIcon(getClass().getResource("/bg/menu_setting.png")));
+        settingMenu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        menuBar.add(settingMenu);
+        JMenuItem resetTcpMenu_1 = new JMenuItem("刷新OP050A工件");
+        resetTcpMenu_1.setIcon(new ImageIcon(MesClient.class.getResource("/bg/reset_logo.png")));
+        resetTcpMenu_1.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        resetTcpMenu_1.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {
+                super.mouseClicked(e);
+                if (!MultiStationClient.mainFrame.stationPanels.isEmpty()) {
+                    MultiStationClient.mainFrame.stationPanels.get(0).resetScanA();
+                }
+            }
+        });
+        settingMenu.add(resetTcpMenu_1);
+
+        JMenuItem resetTcpMenu_2 = new JMenuItem("刷新OP060A工件");
+        resetTcpMenu_2.setIcon(new ImageIcon(MesClient.class.getResource("/bg/reset_logo.png")));
+        resetTcpMenu_2.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        resetTcpMenu_2.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {
+                super.mouseClicked(e);
+                if (!MultiStationClient.mainFrame.stationPanels.isEmpty()) {
+                    MultiStationClient.mainFrame.stationPanels.get(1).resetScanA();
+                }
+            }
+        });
+        settingMenu.add(resetTcpMenu_2);
+
+        JMenuItem resetTcpMenu_3 = new JMenuItem("刷新OP070A工件");
+        resetTcpMenu_3.setIcon(new ImageIcon(MesClient.class.getResource("/bg/reset_logo.png")));
+        resetTcpMenu_3.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        resetTcpMenu_3.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {
+                super.mouseClicked(e);
+                if (!MultiStationClient.mainFrame.stationPanels.isEmpty()) {
+                    MultiStationClient.mainFrame.stationPanels.get(2).resetScanA();
+                }
+            }
+        });
+        settingMenu.add(resetTcpMenu_3);
+
+        JMenuItem resetTcpMenu_4 = new JMenuItem("刷新OP080A工件");
+        resetTcpMenu_4.setIcon(new ImageIcon(MesClient.class.getResource("/bg/reset_logo.png")));
+        resetTcpMenu_4.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        resetTcpMenu_4.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {
+                super.mouseClicked(e);
+                if (!MultiStationClient.mainFrame.stationPanels.isEmpty()) {
+                    MultiStationClient.mainFrame.stationPanels.get(3).resetScanA();
+                }
+            }
+        });
+        settingMenu.add(resetTcpMenu_4);
+
+        JMenuItem resetTcpMenu_5 = new JMenuItem("刷新OP090A工件");
+        resetTcpMenu_5.setIcon(new ImageIcon(MesClient.class.getResource("/bg/reset_logo.png")));
+        resetTcpMenu_5.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        resetTcpMenu_5.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {
+                super.mouseClicked(e);
+                if (!MultiStationClient.mainFrame.stationPanels.isEmpty()) {
+                    MultiStationClient.mainFrame.stationPanels.get(4).resetScanA();
+                }
+            }
+        });
+        settingMenu.add(resetTcpMenu_5);
+
+        JMenuItem resetTcpMenu_6 = new JMenuItem("刷新OP160A工件");
+        resetTcpMenu_6.setIcon(new ImageIcon(MesClient.class.getResource("/bg/reset_logo.png")));
+        resetTcpMenu_6.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        resetTcpMenu_6.addMouseListener(new MouseAdapter() {
+            @Override
+            public void mousePressed(MouseEvent e) {
+                super.mouseClicked(e);
+                if (!MultiStationClient.mainFrame.stationPanels.isEmpty()) {
+                    MultiStationClient.mainFrame.stationPanels.get(5).resetScanA();
+                }
+            }
+        });
+        settingMenu.add(resetTcpMenu_6);
+        
+        JToolBar toolBar = new JToolBar();
+        toolBar.setFloatable(false);
+        
+        JLabel statusLabelTitle = new JLabel("状态：");
+        statusLabelTitle.setFont(new Font("微软雅黑", Font.PLAIN, 24));
+        toolBar.add(statusLabelTitle);
+        
+        statusLabel = new JLabel("已连接MES服务器");
+        statusLabel.setForeground(Color.GREEN);
+        statusLabel.setFont(new Font("微软雅黑", Font.PLAIN, 24));
+        statusLabel.setBackground(Color.BLACK);
+        toolBar.add(statusLabel);
+        
+        toolBar.add(Box.createHorizontalStrut(20));
+        
+        JLabel heartBeatTitle = new JLabel("心跳：");
+        heartBeatTitle.setFont(new Font("微软雅黑", Font.PLAIN, 24));
+        toolBar.add(heartBeatTitle);
+        
+        heartBeatLabel = new JLabel(new ImageIcon(getClass().getResource("/bg/green_dot.png")));
+        toolBar.add(heartBeatLabel);
+        
+        toolBar.add(Box.createHorizontalStrut(20));
+        
+        JLabel userTitle = new JLabel("登录用户：");
+        userTitle.setFont(new Font("微软雅黑", Font.PLAIN, 24));
+        toolBar.add(userTitle);
+        
+        userMenu = new JButton("未知用户");
+        userMenu.setForeground(Color.GREEN);
+        userMenu.setFont(new Font("微软雅黑", Font.PLAIN, 24));
+        userMenu.setBackground(Color.BLACK);
+        toolBar.add(userMenu);
+        
+        add(toolBar, BorderLayout.NORTH);
+
+        JTabbedPane tabbedPane = new JTabbedPane();
+        tabbedPane.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+
+        try {
+            List<StationConfig> stations = StationConfig.loadAllStations();
+            if (stations.isEmpty()) {
+                JOptionPane.showMessageDialog(this, "未配置任何工位", "错误", JOptionPane.ERROR_MESSAGE);
+                return;
+            }
+            
+            JPanel mainPanel = new JPanel(new GridLayout(2, 3, 1, 1));
+            mainPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+            mainPanel.setBackground(Color.WHITE);
+
+            for (StationConfig config : stations) {
+                WorkStationPanel panel = new WorkStationPanel(config);
+                stationPanels.add(panel);
+                mainPanel.add(panel);
+            }
+            
+            tabbedPane.addTab("工作面板",new ImageIcon(MesClient.class.getResource("/bg/a_side.png")), new JScrollPane(mainPanel));
+            indexPaneCheck = new JPanel();
+            searchScrollPaneCheck = new JScrollPane(indexPaneCheck);
+            indexPaneCheck.setLayout(null);
+//            tabbedPane.addTab("开班点检", new ImageIcon(MesClient.class.getResource("/bg/menu_data_preprocess.png")),searchScrollPaneCheck);
+            indexPaneWork = new JPanel();
+            searchScrollPaneWork = new JScrollPane(indexPaneWork);
+//            tabbedPane.addTab("生产记录",new ImageIcon(MesClient.class.getResource("/bg/menu_data_preprocess.png")),searchScrollPaneWork);
+            
+            add(tabbedPane, BorderLayout.CENTER);
+            
+        } catch (IOException e) {
+            JOptionPane.showMessageDialog(this, "加载工位配置失败: " + e.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
+        }
+        
+        pack();
+        setExtendedState(JFrame.MAXIMIZED_BOTH);
+    }
+
+    public void setUser(String user) {
+        userMenu.setText(user);
+        if (stationPanels != null) {
+            for (WorkStationPanel panel : stationPanels) {
+                panel.setCurrentUser(user);
+            }
+        }
+    }
+}

src/com/mes/ui/OprnoUtil.java

@@ -0,0 +1,79 @@
+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[]{
+            "OP030","OP080", "OP100",
+            "OP110", "OP120", "OP130", "OP140", "OP150",
+            "OP160", "OP170", "OP180", "OP190", "OP200",
+            "OP210", "OP220", "OP230", "OP240", "OP250",
+            "OP260", "OP270", "OP280", "OP290", "OP300",
+            "OP310", "OP320", "OP330", "OP340", "OP350",
+            "OP360", "OP370", "OP380", "OP390", "OP400",
+            "OP410", "OP420", "OP430", "OP440", "OP450",
+            "OP460", "OP470", "OP480", "OP490", "OP500",
+            "OP520", "OP510", "OP550"
+    };
+    public static String[] xtoprnodes = new String[]{
+            "凸焊","左边梁防爆阀拉铆","CMT框架一序焊接",
+            "人工补焊", "框架CMT二序焊接", "人工补焊", "焊道检查", "总成正面CNC",
+            "总成反面CNC", "框架去毛刺+清洁", "封堵片焊接+打磨", "边框气密", "焊道补焊",
+            "框架反面涂胶", "液冷板安装", "正面溢胶清理,补胶", "液冷板激光点固", "液冷板水嘴处焊接",
+            "焊道打磨", "液冷板FSW", "匙孔补焊打磨", "总成反面拉铆", "总成正面拉铆1",
+            "总成正面拉铆2", "边梁套筒涂胶+压合", "箱体封堵", "胶水固化", "半成品气密",
+            "补强板安装", "胶水固化", "拆卸补强板压紧工装", "FSW焊道涂胶+双层拉铆螺母涂胶", "人工抹胶",
+            "胶水固化", "反面部件装配", "底护板装配+底部套筒螺母安装", "底护板螺栓复拧", "总成气密",
+            "液冷板气密", "总成正面装配", "总成清洁", "总成检具检验", "GP12",
+            "CCD", "GP12", "称重"
+    };
+    public static String[] lboprnos = new String[]{
+            "OP040", "OP050", "OP060", "OP070", "OP080",
+            "OP090", "OP100", "OP110", "OP120", "OP130",
+            "OP140", "OP150"
+    };
+    public static String[] lboprnodes = new String[]{
+            "镭雕二维码", "底护板封堵片焊接", "底护板FSW", "焊道打磨", "底板反面CNC",
+            "底护板清洁", "底护板粘贴底部钢板", "底护板封堵+刮胶", "底护板静置封堵胶固化", "底护板清洁",
+            "底护板粘贴底部泡棉缓冲垫+保温板", "终检"
+    };
+    public static String getGwDes(String lineSn,String oprno){
+        String des = "";
+        oprno = formatOprno(oprno);
+        if(lineSn.equals("HEVXT")){
+            int i = 0;
+            for (String gw:xtoprnos){
+                if(gw.equals(oprno)){
+                    des = xtoprnodes[i];
+                    break;
+                }
+                i++;
+            }
+        }else if(lineSn.equals("LB")){
+            int i = 0;
+            for (String gw:lboprnos){
+                if(gw.equals(oprno)){
+                    des = lboprnodes[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/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/ui/WorkRecordData.java

@@ -0,0 +1,61 @@
+package com.mes.ui;
+
+/**
+ * 工作记录数据实体类
+ */
+public class WorkRecordData {
+    private String id;
+    private String sn;          // 工件码
+    private String oprno;       // 工位号
+    private String updateBy;    // 作业人员
+    private String updateDate;  // 日期
+    private String content;     // 工位结果
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getSn() {
+        return sn;
+    }
+
+    public void setSn(String sn) {
+        this.sn = sn;
+    }
+
+    public String getOprno() {
+        return oprno;
+    }
+
+    public void setOprno(String oprno) {
+        this.oprno = oprno;
+    }
+
+    public String getUpdateBy() {
+        return updateBy;
+    }
+
+    public void setUpdateBy(String updateBy) {
+        this.updateBy = updateBy;
+    }
+
+    public String getUpdateDate() {
+        return updateDate;
+    }
+
+    public void setUpdateDate(String updateDate) {
+        this.updateDate = updateDate;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public void setContent(String content) {
+        this.content = content;
+    }
+}

src/com/mes/ui/WorkRecordPanel.java

@@ -0,0 +1,403 @@
+package com.mes.ui;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.swing.*;
+import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.DefaultTableModel;
+import javax.swing.table.TableColumn;
+import java.awt.*;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
+import java.util.List;
+
+/**
+ * 工作记录面板组件
+ * 支持分页查询和展示工作记录数据
+ */
+public class WorkRecordPanel extends JPanel {
+
+    private static final Logger log = LoggerFactory.getLogger(WorkRecordPanel.class);
+
+    // 表格列名
+    private static final String[] COLUMN_NAMES = {"工件码", "工位号", "工位结果", "作业人员", "日期"};
+
+    // 分页配置
+    private static final int PAGE_SIZE = 20;
+
+    // 查询条件
+    private String oprno;  // 工位号（null或空则查全部）
+    private String lineSn; // 产线编号
+    private boolean isAllStation; // 是否是"所有工位"模式
+
+    // 分页状态
+    private int pageNo = 1;
+    private long totalCount = 0;
+    private int totalPages = 0;
+
+    // UI组件
+    private JTable table;
+    private DefaultTableModel tableModel;
+    private JLabel pageLabel;
+    private JButton btnPrevious;
+    private JButton btnNext;
+    private JButton btnRefresh;
+    private JButton btnSearch;
+    private JLabel statusLabel;
+    private JTextField snSearchField;      // 工件码搜索框
+    private JTextField oprnoSearchField;   // 工位号搜索框（仅"所有工位"模式）
+    private JLabel snLabel;
+    private JLabel oprnoLabel;
+
+    /**
+     * 构造函数
+     * @param oprno 工位号（如OP150A查询该工位，null或空则查所有工位）
+     * @param lineSn 产线编号
+     */
+    public WorkRecordPanel(String oprno, String lineSn) {
+        this.oprno = oprno;
+        this.lineSn = lineSn;
+        this.isAllStation = (oprno == null || oprno.isEmpty());
+        initUI();
+    }
+
+    /**
+     * 初始化UI
+     */
+    private void initUI() {
+        setLayout(null);
+        setBackground(Color.WHITE);
+
+        // 顶部控制区
+        JPanel topPanel = new JPanel();
+        topPanel.setLayout(null);
+        topPanel.setBounds(0, 0, 1200, 70);
+        topPanel.setBackground(new Color(248, 248, 248));
+        add(topPanel);
+
+        int xPos = 10;
+
+        // 状态标签
+        String displayOprno = isAllStation ? "所有工位" : oprno;
+        statusLabel = new JLabel("工位：" + displayOprno);
+        statusLabel.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        statusLabel.setBounds(xPos, 10, 250, 30);
+        topPanel.add(statusLabel);
+        xPos += 165;
+
+        // 工件码搜索
+        snLabel = new JLabel("工件码:");
+        snLabel.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        snLabel.setBounds(xPos+100, 10, 100, 30);
+        topPanel.add(snLabel);
+        xPos += 200;
+
+        snSearchField = new JTextField();
+        snSearchField.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        snSearchField.setBounds(xPos, 10, 250, 40);
+        snSearchField.addActionListener(e -> doSearch()); // 回车搜索
+        topPanel.add(snSearchField);
+        xPos += 210;
+
+        // 工位号搜索（仅"所有工位"模式显示）
+        if (isAllStation) {
+            oprnoLabel = new JLabel("工位:");
+            oprnoLabel.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+            oprnoLabel.setBounds(xPos, 10, 40, 30);
+            topPanel.add(oprnoLabel);
+            xPos += 100;
+
+            oprnoSearchField = new JTextField();
+            oprnoSearchField.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+            oprnoSearchField.setBounds(xPos, 10, 100, 30);
+            oprnoSearchField.addActionListener(e -> doSearch()); // 回车搜索
+            topPanel.add(oprnoSearchField);
+            xPos += 110;
+        }
+
+        // 查询按钮
+        btnSearch = new JButton("查询");
+        btnSearch.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        btnSearch.setBounds(xPos+100, 10, 120, 40);
+        btnSearch.addActionListener(e -> doSearch());
+        topPanel.add(btnSearch);
+        xPos += 80;
+
+        // 刷新按钮
+        btnRefresh = new JButton("刷新");
+        btnRefresh.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        btnRefresh.setBounds(xPos+150, 10, 120, 40);
+        btnRefresh.addActionListener(e -> {
+            clearSearchFields();
+            refreshData();
+        });
+        topPanel.add(btnRefresh);
+        xPos += 80;
+
+        // 上一页按钮
+        btnPrevious = new JButton("上一页");
+        btnPrevious.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        btnPrevious.setBounds(xPos+200, 10, 120, 40);
+        btnPrevious.addActionListener(e -> {
+            if (pageNo > 1) {
+                pageNo--;
+                loadData();
+            }
+        });
+        topPanel.add(btnPrevious);
+        xPos += 85;
+
+        // 页码显示
+        pageLabel = new JLabel("0/0");
+        pageLabel.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        pageLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        pageLabel.setBorder(BorderFactory.createLineBorder(Color.GRAY, 1));
+        pageLabel.setBounds(xPos+250, 10, 120, 40);
+        topPanel.add(pageLabel);
+        xPos += 75;
+
+        // 下一页按钮
+        btnNext = new JButton("下一页");
+        btnNext.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        btnNext.setBounds(xPos+300, 10, 120, 40);
+        btnNext.addActionListener(e -> {
+            if (pageNo < totalPages) {
+                pageNo++;
+                loadData();
+            }
+        });
+        topPanel.add(btnNext);
+
+        // 表格面板
+        JPanel tablePanel = new JPanel();
+        tablePanel.setBounds(0, 50, 1200, 518);
+        tablePanel.setLayout(new GridLayout(1, 1, 0, 0));
+        add(tablePanel);
+
+        // 创建表格模型
+        tableModel = new DefaultTableModel(COLUMN_NAMES, 0) {
+            @Override
+            public boolean isCellEditable(int row, int column) {
+                return false;
+            }
+        };
+
+        // 创建表格
+        table = new JTable(tableModel);
+        table.setRowHeight(32);
+        table.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        table.getTableHeader().setFont(new Font("微软雅黑", Font.BOLD, 30));
+        table.getTableHeader().setReorderingAllowed(false);
+
+        // 设置列宽
+        setColumnWidths();
+
+        // 设置居中渲染器
+        DefaultTableCellRenderer centerRenderer = new DefaultTableCellRenderer();
+        centerRenderer.setHorizontalAlignment(JLabel.CENTER);
+        for (int i = 0; i < table.getColumnCount(); i++) {
+            table.getColumnModel().getColumn(i).setCellRenderer(centerRenderer);
+        }
+
+        // 添加滚动面板
+        JScrollPane scrollPane = new JScrollPane(table);
+        tablePanel.add(scrollPane);
+
+        // 添加组件大小变化监听器
+        addComponentListener(new ComponentAdapter() {
+            @Override
+            public void componentResized(ComponentEvent e) {
+                int w = getWidth();
+                int h = getHeight();
+
+                // 调整顶部面板宽度
+                topPanel.setBounds(0, 0, w, 60);
+
+                // 调整表格面板
+                if (h > 50) {
+                    tablePanel.setBounds(0, 60, w, h - 60);
+                }
+
+                topPanel.revalidate();
+                tablePanel.revalidate();
+            }
+        });
+    }
+
+    /**
+     * 设置列宽
+     */
+    private void setColumnWidths() {
+        TableColumn column;
+        // 工件码
+        column = table.getColumnModel().getColumn(0);
+        column.setPreferredWidth(260);
+        // 工位号
+        column = table.getColumnModel().getColumn(1);
+        column.setPreferredWidth(90);
+        // 工位结果
+        column = table.getColumnModel().getColumn(2);
+        column.setPreferredWidth(70);
+        // 作业人员
+        column = table.getColumnModel().getColumn(3);
+        column.setPreferredWidth(100);
+        // 日期
+        column = table.getColumnModel().getColumn(4);
+        column.setPreferredWidth(150);
+    }
+
+    /**
+     * 清空搜索框
+     */
+    private void clearSearchFields() {
+        snSearchField.setText("");
+        if (oprnoSearchField != null) {
+            oprnoSearchField.setText("");
+        }
+    }
+
+    /**
+     * 执行搜索
+     */
+    private void doSearch() {
+        pageNo = 1;
+        loadData();
+    }
+
+    /**
+     * 刷新数据（重置到第一页）
+     */
+    public void refreshData() {
+        pageNo = 1;
+        loadData();
+    }
+
+    /**
+     * 加载数据
+     */
+    public void loadData() {
+        // 获取搜索条件
+        String searchSn = snSearchField.getText().trim();
+        String searchOprno = oprno; // 默认使用构造函数传入的工位号
+
+        // 如果是"所有工位"模式，检查是否有工位号搜索条件
+        if (isAllStation && oprnoSearchField != null) {
+            String inputOprno = oprnoSearchField.getText().trim();
+            if (!inputOprno.isEmpty()) {
+                searchOprno = inputOprno;
+            }
+        }
+
+        final String finalSearchOprno = searchOprno;
+        final String finalSearchSn = searchSn;
+
+        // 在后台线程中执行数据加载
+        SwingWorker<WorkRecordResp, Void> worker = new SwingWorker<WorkRecordResp, Void>() {
+            @Override
+            protected WorkRecordResp doInBackground() throws Exception {
+                // 更新状态
+                SwingUtilities.invokeLater(() -> {
+                    statusLabel.setText("正在加载...");
+                    setButtonsEnabled(false);
+                });
+
+                // 调用接口查询数据
+                return DataUtil.getWorkRecordList(finalSearchOprno, finalSearchSn, pageNo, PAGE_SIZE);
+            }
+
+            @Override
+            protected void done() {
+                try {
+                    WorkRecordResp resp = get();
+                    updateUI(resp, finalSearchOprno);
+                } catch (Exception e) {
+                    log.error("加载工作记录失败: {}", e.getMessage());
+                    updateUIError("加载失败: " + e.getMessage());
+                }
+            }
+        };
+        worker.execute();
+    }
+
+    /**
+     * 设置按钮启用状态
+     */
+    private void setButtonsEnabled(boolean enabled) {
+        btnSearch.setEnabled(enabled);
+        btnRefresh.setEnabled(enabled);
+        btnPrevious.setEnabled(enabled && pageNo > 1);
+        btnNext.setEnabled(enabled && pageNo < totalPages);
+    }
+
+    /**
+     * 更新UI显示数据
+     */
+    private void updateUI(WorkRecordResp resp, String queryOprno) {
+        // 清空表格
+        tableModel.setRowCount(0);
+
+        if (resp == null || !resp.isResult()) {
+            String msg = resp != null ? resp.getMessage() : "请求失败";
+            updateUIError(msg);
+            return;
+        }
+
+        // 更新分页信息
+        totalCount = resp.getCount();
+        totalPages = (int) Math.ceil((double) totalCount / PAGE_SIZE);
+        if (totalPages == 0) totalPages = 1;
+
+        // 更新页码显示
+        pageLabel.setText(pageNo + "/" + totalPages);
+
+        // 更新按钮状态
+        setButtonsEnabled(true);
+
+        // 更新状态标签
+        String oprnoDisplay;
+        if (isAllStation) {
+            oprnoDisplay = (queryOprno == null || queryOprno.isEmpty()) ? "所有工位" : queryOprno;
+        } else {
+            oprnoDisplay = oprno;
+        }
+        statusLabel.setText("工位：" + oprnoDisplay + " 共" + totalCount + "条");
+
+        // 填充表格数据
+        List<WorkRecordData> list = resp.getList();
+        if (list != null && !list.isEmpty()) {
+            for (WorkRecordData data : list) {
+                Object[] row = {
+                        data.getSn(),
+                        data.getOprno(),
+                        data.getContent(),
+                        data.getUpdateBy(),
+                        data.getUpdateDate()
+                };
+                tableModel.addRow(row);
+            }
+        }
+
+        // 刷新表格
+        table.repaint();
+    }
+
+    /**
+     * 更新UI显示错误信息
+     */
+    private void updateUIError(String message) {
+        statusLabel.setText("错误: " + message);
+        pageLabel.setText("0/0");
+        setButtonsEnabled(true);
+        btnPrevious.setEnabled(false);
+        btnNext.setEnabled(false);
+        tableModel.setRowCount(0);
+    }
+
+    /**
+     * 获取当前工位号
+     */
+    public String getOprno() {
+        return oprno;
+    }
+}

src/com/mes/ui/WorkRecordResp.java

@@ -0,0 +1,63 @@
+package com.mes.ui;
+
+import java.util.List;
+
+/**
+ * 工作记录查询响应实体类
+ */
+public class WorkRecordResp {
+    private boolean result;
+    private String message;
+    private int pageNo;
+    private int pageSize;
+    private long count;
+    private List<WorkRecordData> list;
+
+    public boolean isResult() {
+        return result;
+    }
+
+    public void setResult(boolean result) {
+        this.result = result;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public int getPageNo() {
+        return pageNo;
+    }
+
+    public void setPageNo(int pageNo) {
+        this.pageNo = pageNo;
+    }
+
+    public int getPageSize() {
+        return pageSize;
+    }
+
+    public void setPageSize(int pageSize) {
+        this.pageSize = pageSize;
+    }
+
+    public long getCount() {
+        return count;
+    }
+
+    public void setCount(long count) {
+        this.count = count;
+    }
+
+    public List<WorkRecordData> getList() {
+        return list;
+    }
+
+    public void setList(List<WorkRecordData> list) {
+        this.list = list;
+    }
+}

src/com/mes/ui/WorkStationPanel.java

@@ -0,0 +1,756 @@
+package com.mes.ui;
+
+import com.alibaba.fastjson2.JSONObject;
+import com.mes.component.MesWebView;
+import com.mes.util.PLCUtils;
+import com.mes.util.StationConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.swing.*;
+import javax.swing.border.TitledBorder;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class WorkStationPanel extends JPanel {
+    private static final Logger log = LoggerFactory.getLogger(WorkStationPanel.class);
+    private static final long PLC_STATUS_REFRESH_INTERVAL_MS = 3000L;
+    private static final long PLC_STATUS_RETRY_BACKOFF_MS = 10000L;
+    private static final long PLC_STATUS_WARN_INTERVAL_MS = 30000L;
+    private static final long PLC_WORKFLOW_WARN_INTERVAL_MS = 30000L;
+    private String gw;
+    private String gwDes;
+    private String lineSn;
+    private String serverIp;
+
+    private String allowStart;
+    private String allowDown;
+    private String startMethod;
+    private String stopMethod;
+    private StationConfig stationConfig;
+    
+    public int workStatus = 0;
+    public int plcStatus = 0;
+    public boolean checkQualityResult = false;
+    private String currentUser = "system";
+    private String lastWeldingParamContent = "";
+    private PLCUtils.WeldingParamSampler weldingParamSampler;
+
+    public static List<String> hjparams = new ArrayList<>();
+    
+    public JTextField productSnField;
+    public JButton scanButton;
+    public JButton finishOkButton;
+    public JButton finishNgButton;
+    private JLabel statusLabel;
+    private JLabel heartBeatLabel;
+    private JLabel fxLabel;
+    private final Map<String, JLabel> plcStatusDots = new LinkedHashMap<>();
+    private final Map<String, Boolean> plcStatusValues = new LinkedHashMap<>();
+    public static Object[][] rowData = null;
+    
+    private Timer heartBeatTimer;
+    private Timer getSnBeatTimer;
+    private Timer plcStatusTimer;
+    private int plcStatusReadFailCount = 0;
+    private long nextPlcStatusReadTime = 0L;
+    private long lastPlcStatusWarnTime = 0L;
+    private int plcWorkflowFailCount = 0;
+    private long lastPlcWorkflowWarnTime = 0L;
+    private long nextPlcWorkflowTime = 0L;
+
+    private boolean iconREDFlag = true;
+
+    public WorkStationPanel(String gw, String gwDes, String lineSn, String serverIp, String allowStart, String allowDown, String startMethod, String stopMethod) {
+        this.gw = gw;
+        this.gwDes = gwDes;
+        this.lineSn = lineSn;
+        this.serverIp = serverIp;
+        this.allowStart = allowStart;
+        this.allowDown = allowDown;
+        this.startMethod = startMethod;
+        this.stopMethod = stopMethod;
+        initUI();
+        startHeartBeatTimer();
+        startPlcStatusTimer();
+        startGetCurSn();
+    }
+
+    public WorkStationPanel(StationConfig stationConfig) {
+        this.gw = stationConfig.getGw();
+        this.gwDes = stationConfig.getGwDes();
+        this.lineSn = stationConfig.getLineSn();
+        this.serverIp = stationConfig.getServerIp();
+        this.allowStart = stationConfig.getAllowStart();
+        this.allowDown = stationConfig.getAllowDown();
+        this.startMethod = stationConfig.getStartMethod();
+        this.stopMethod = stationConfig.getStopMethod();
+        this.stationConfig = stationConfig;
+        initUI();
+        startHeartBeatTimer();
+        startPlcStatusTimer();
+        startGetCurSn();
+    }
+
+    private void initUI() {
+        setBorder(BorderFactory.createTitledBorder(BorderFactory.createLineBorder(Color.BLACK), 
+            gw + " - " + gwDes, 
+            TitledBorder.CENTER, 
+            TitledBorder.TOP,
+            new Font("微软雅黑", Font.BOLD, 20),
+            Color.BLUE));
+        
+        setLayout(new BorderLayout(5, 5));
+        setBackground(Color.WHITE);
+
+        JPanel topPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 10, 5));
+        topPanel.setBackground(Color.WHITE);
+        
+        statusLabel = new JLabel("等待扫码");
+        statusLabel.setFont(new Font("微软雅黑", Font.PLAIN, 20));
+        statusLabel.setForeground(Color.RED);
+        topPanel.add(statusLabel);
+        
+        heartBeatLabel = new JLabel(new ImageIcon(getClass().getResource("/bg/grey_dot.png")));
+        topPanel.add(heartBeatLabel);
+        
+        add(topPanel, BorderLayout.NORTH);
+
+        JPanel centerPanel = new JPanel();
+        centerPanel.setLayout(new BoxLayout(centerPanel, BoxLayout.Y_AXIS));
+        centerPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+
+        fxLabel = new JLabel("该工件为返修件，请仔细检查");
+        fxLabel.setFont(new Font("微软雅黑", Font.PLAIN, 16));
+        fxLabel.setForeground(Color.RED);
+        fxLabel.setHorizontalAlignment(SwingConstants.CENTER);
+        fxLabel.setVisible(false);
+        centerPanel.add(fxLabel);
+
+        productSnField = new JTextField();
+        productSnField.setHorizontalAlignment(SwingConstants.CENTER);
+        productSnField.setEditable(false);
+        productSnField.setFont(new Font("微软雅黑", Font.BOLD, 15));
+        productSnField.setBorder(BorderFactory.createLineBorder(Color.BLACK, 1));
+        productSnField.setColumns(15);
+        productSnField.setPreferredSize(new Dimension(100, 30));
+        scanButton = new JButton("扫码");
+//        scanButton.setIcon(new ImageIcon(getClass().getResource("/bg/scan_barcode.png")));
+        scanButton.setFont(new Font("微软雅黑", Font.PLAIN, 15));
+        scanButton.setPreferredSize(new Dimension(70, 30));
+        scanButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                try {
+                    JSONObject result = DataUtil.getCurSn(gw, serverIp, lineSn);
+                    
+                    if (result == null) {
+                        JOptionPane.showMessageDialog(WorkStationPanel.this, "获取工件码失败", "错误", JOptionPane.ERROR_MESSAGE);
+                        return;
+                    }
+                    
+                    // 检查是否需要登录
+                    if (result.containsKey("result") && "login".equalsIgnoreCase(result.getString("result"))) {
+                        String message = result.containsKey("message") ? result.getString("message") : "";
+                        JOptionPane.showMessageDialog(WorkStationPanel.this, "登录超时，请重新登录！\n" + message, "登录提示", JOptionPane.WARNING_MESSAGE);
+                        // 切换到登录窗口
+                        if (MultiStationClient.welcomeWin != null) {
+                            MultiStationClient.welcomeWin.setVisible(true);
+                        }
+                        return;
+                    }
+                    
+                    // 正常处理结果
+                    if (result.containsKey("data")) {
+                        String data = result.getString("data");
+                        if (data != null && !data.isEmpty()) {
+                            productSnField.setText(data);
+                            checkQuality(data);
+                        } else {
+                            JOptionPane.showMessageDialog(WorkStationPanel.this, "获取工件码为空", "提示", JOptionPane.INFORMATION_MESSAGE);
+                        }
+                    } else {
+                        JOptionPane.showMessageDialog(WorkStationPanel.this, result.get("message"), "错误", JOptionPane.ERROR_MESSAGE);
+                    }
+                } catch (Exception ex) {
+                    JOptionPane.showMessageDialog(WorkStationPanel.this, "扫码异常: " + ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
+                }
+            }
+        });
+
+        JPanel linePanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 1, 0));
+        linePanel.add(productSnField);
+        linePanel.add(scanButton);
+        centerPanel.add(linePanel);
+
+        JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 15, 10));
+        buttonPanel.setBackground(Color.WHITE);
+        finishOkButton = new JButton("OK");
+        finishOkButton.setIcon(new ImageIcon(getClass().getResource("/bg/ok_bg.png")));
+        finishOkButton.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        finishOkButton.setPreferredSize(new Dimension(120, 30));
+        finishOkButton.setEnabled(false);
+        finishOkButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                submitResult("OK");
+            }
+        });
+        buttonPanel.add(finishOkButton);
+
+        // NG按钮
+        finishNgButton = new JButton("NG");
+        finishNgButton.setFont(new Font("微软雅黑", Font.PLAIN, 25));
+        finishNgButton.setIcon(new ImageIcon(MesClient.class.getResource("/bg/ng_bg.png")));
+        finishNgButton.setPreferredSize(new Dimension(120, 30));
+        finishNgButton.setEnabled(false);
+        finishNgButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                submitResult("NG");
+//                resetScanA();
+            }
+        });
+        buttonPanel.add(finishNgButton);
+
+        centerPanel.add(buttonPanel);
+
+        JPanel plcStatusPanel = createPlcStatusPanel();
+        centerPanel.add(plcStatusPanel);
+
+        add(centerPanel, BorderLayout.CENTER);
+
+        JPanel bottomPanel = new JPanel(new BorderLayout());
+        bottomPanel.setBackground(Color.WHITE);
+        bottomPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
+
+        JButton checkRecordButton = new JButton("点检记录");
+        checkRecordButton.setFont(new Font("微软雅黑", Font.PLAIN, 15));
+        checkRecordButton.setPreferredSize(new Dimension(100, 30));
+        checkRecordButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                showCheckRecordDialog();
+            }
+        });
+
+        JButton workRecordButton = new JButton("工作记录");
+        workRecordButton.setFont(new Font("微软雅黑", Font.PLAIN, 15));
+        workRecordButton.setPreferredSize(new Dimension(100, 30));
+        workRecordButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                showWorkRecordDialog();
+            }
+        });
+
+        JPanel leftBottomPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 0, 0));
+        leftBottomPanel.setBackground(Color.WHITE);
+        leftBottomPanel.add(checkRecordButton);
+
+        JPanel rightBottomPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT, 0, 0));
+        rightBottomPanel.setBackground(Color.WHITE);
+        rightBottomPanel.add(workRecordButton);
+
+        bottomPanel.add(leftBottomPanel, BorderLayout.WEST);
+        bottomPanel.add(rightBottomPanel, BorderLayout.EAST);
+        add(bottomPanel, BorderLayout.SOUTH);
+    }
+
+    private JPanel createPlcStatusPanel() {
+        JPanel plcStatusPanel = new JPanel(new GridLayout(3, 1, 0, 3));
+        plcStatusPanel.setBackground(Color.WHITE);
+        plcStatusPanel.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 20));
+
+        JPanel firstLine = createPlcStatusLine();
+        addPlcStatusItem(firstLine, "allowStart", "允许启动", true);
+        addPlcStatusItem(firstLine, "allowDown", "允许下料", true);
+        plcStatusPanel.add(firstLine);
+
+        JPanel secondLine = createPlcStatusLine();
+        addPlcStatusItem(secondLine, "start", "开始加工", false);
+        addPlcStatusItem(secondLine, "finish", "加工结束", false);
+        plcStatusPanel.add(secondLine);
+
+        JPanel thirdLine = createPlcStatusLine();
+        addPlcStatusItem(thirdLine, "fault", "故障", false);
+        plcStatusPanel.add(thirdLine);
+        return plcStatusPanel;
+    }
+
+    private JPanel createPlcStatusLine() {
+        JPanel linePanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 14, 0));
+        linePanel.setBackground(Color.WHITE);
+        return linePanel;
+    }
+
+    private void addPlcStatusItem(JPanel parent, final String key, String title, boolean clickable) {
+        JPanel itemPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 4, 0));
+        itemPanel.setBackground(Color.WHITE);
+
+        JLabel titleLabel = new JLabel(title);
+        titleLabel.setFont(new Font("微软雅黑", Font.PLAIN, 14));
+        titleLabel.setPreferredSize(new Dimension(62, 20));
+        titleLabel.setHorizontalAlignment(SwingConstants.RIGHT);
+        itemPanel.add(titleLabel);
+
+        JLabel dotLabel = new JLabel(greyDotIcon());
+        dotLabel.setPreferredSize(new Dimension(20, 20));
+        if (clickable) {
+            dotLabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
+            titleLabel.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
+            MouseAdapter adapter = new MouseAdapter() {
+                @Override
+                public void mouseClicked(MouseEvent e) {
+                    toggleWritablePlcStatus(key);
+                }
+            };
+            dotLabel.addMouseListener(adapter);
+            titleLabel.addMouseListener(adapter);
+        }
+        itemPanel.add(dotLabel);
+
+        plcStatusDots.put(key, dotLabel);
+        plcStatusValues.put(key, false);
+        parent.add(itemPanel);
+    }
+
+    private ImageIcon greenDotIcon() {
+        return new ImageIcon(getClass().getResource("/bg/green_dot.png"));
+    }
+
+    private ImageIcon greyDotIcon() {
+        return new ImageIcon(getClass().getResource("/bg/grey_dot.png"));
+    }
+
+    private void toggleWritablePlcStatus(final String key) {
+        if (stationConfig == null) {
+            JOptionPane.showMessageDialog(this, "未加载PLC工位配置，无法切换状态", "提示", JOptionPane.WARNING_MESSAGE);
+            return;
+        }
+
+        final boolean newValue = !Boolean.TRUE.equals(plcStatusValues.get(key));
+        String statusName = "allowStart".equals(key) ? "允许启动" : "允许下料";
+        String actionName = newValue ? "开启" : "关闭";
+        int confirm = JOptionPane.showConfirmDialog(
+                this,
+                "确定要" + actionName + "【" + statusName + "】吗？",
+                "确认更改",
+                JOptionPane.YES_NO_OPTION,
+                JOptionPane.QUESTION_MESSAGE);
+        if (confirm != JOptionPane.YES_OPTION) {
+            return;
+        }
+
+        setPlcStatusDot(key, newValue);
+
+        SwingWorker<Boolean, Void> worker = new SwingWorker<Boolean, Void>() {
+            @Override
+            protected Boolean doInBackground() {
+                if ("allowStart".equals(key)) {
+                    return PLCUtils.writeAllowStart(stationConfig, newValue);
+                }
+                if ("allowDown".equals(key)) {
+                    return PLCUtils.writeAllowDown(stationConfig, newValue);
+                }
+                return false;
+            }
+
+            @Override
+            protected void done() {
+                try {
+                    if (!get()) {
+                        setPlcStatusDot(key, !newValue);
+                    }
+                } catch (Exception ex) {
+                    setPlcStatusDot(key, !newValue);
+                    JOptionPane.showMessageDialog(WorkStationPanel.this, "PLC状态切换失败：" + ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
+                }
+            }
+        };
+        worker.execute();
+    }
+
+    private void setPlcStatusDot(String key, boolean value) {
+        plcStatusValues.put(key, value);
+        JLabel dot = plcStatusDots.get(key);
+        if (dot != null) {
+            dot.setIcon(value ? greenDotIcon() : greyDotIcon());
+        }
+    }
+
+
+    private void checkQuality(String sn) {
+        JSONObject retObj = DataUtil.checkQuality(sn, currentUser, gw, lineSn, serverIp);
+        if (retObj != null && "true".equalsIgnoreCase(retObj.getString("result"))) {
+            statusLabel.setForeground(Color.GREEN);
+            statusLabel.setText("该工件可以加工");
+            checkQualityResult = true;
+            workStatus = 1;
+            finishOkButton.setEnabled(true);
+            finishNgButton.setEnabled(true);
+            
+            if ("1".equals(retObj.getString("fx"))) {
+                fxLabel.setVisible(true);
+            } else {
+                fxLabel.setVisible(false);
+            }
+        } else {
+            statusLabel.setForeground(Color.RED);
+            String msg = (retObj != null && retObj.containsKey("message")) ? retObj.getString("message") : "检查失败";
+            statusLabel.setText(msg);
+            checkQualityResult = false;
+            workStatus = 0;
+            fxLabel.setVisible(false);
+        }
+    }
+
+    private void submitResult(String result) {
+        if (workStatus == 1 && checkQualityResult) {
+            String sn = productSnField.getText().trim();
+            if (sn.isEmpty()) {
+                statusLabel.setForeground(Color.RED);
+                statusLabel.setText("工件码为空，请重试");
+                return;
+            }
+
+            JSONObject retObj = DataUtil.sendQuality(sn, result, currentUser, gw, lineSn, serverIp);
+            if (retObj != null && "true".equalsIgnoreCase(retObj.getString("result"))) {
+                resetState();
+                statusLabel.setForeground(Color.GREEN);
+                statusLabel.setText("结果提交成功，请扫下一件");
+                finishNgButton.setEnabled(false);
+            } else {
+                statusLabel.setForeground(Color.RED);
+                String msg = (retObj != null && retObj.containsKey("message")) ? retObj.getString("message") : "提交失败";
+                statusLabel.setText(msg);
+            }
+        }
+    }
+
+    private void resetState() {
+        workStatus = 0;
+        plcStatus = 0;
+        checkQualityResult = false;
+        productSnField.setText("");
+        finishOkButton.setEnabled(false);
+        fxLabel.setVisible(false);
+        lastWeldingParamContent = "";
+        stopWeldingParamSampler();
+    }
+
+    public void resetScanA() {
+        JSONObject retObj = DataUtil.delCurSn(gw, serverIp, lineSn);
+        if (retObj.get("result")!=null && retObj.get("result").toString().equalsIgnoreCase("true")) {
+            this.workStatus = 0;
+            this.checkQualityResult = false;
+            finishOkButton.setEnabled(false);
+//        finishNgButton.setEnabled(false);
+            productSnField.setText("");
+            fxLabel.setVisible(false);
+            lastWeldingParamContent = "";
+            stopWeldingParamSampler();
+            PLCUtils.writeStartfalseMethod(stationConfig);
+            scanButton.setEnabled(true);
+            statusLabel.setText("请扫工件码");
+//        MesClient.setMenuStatus("开班点检，请先进行OKNG样件测试",-1);
+
+            updateMaterailData();
+//        shiftUserCheck();
+        } else {
+            statusLabel.setText("刷新失败");
+        }
+
+    }
+    public static void updateMaterailData(){
+        try{
+            JSONObject retObj = DataUtil.getBindMaterail();
+            if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
+                List<BindMaterialResp> arrs = retObj.getList("data",BindMaterialResp.class);
+
+                int i = 0;
+                for (BindMaterialResp bindMaterialResp:arrs){
+                    rowData[i][0] = bindMaterialResp.getMaterialTitle();
+                    rowData[i][1] = bindMaterialResp.getBatchSn();
+                    rowData[i][2] = bindMaterialResp.getLastTimes();
+                    rowData[i][3] = "";
+                    rowData[i][4] = bindMaterialResp.getCraft();
+                    rowData[i][5] = bindMaterialResp.getMaterialId();
+                    rowData[i][6] = bindMaterialResp.getType();
+                    i++;
+                }
+
+//                MesClient.table.repaint();
+            }
+        }catch (Exception e){
+            log.info(e.getMessage());
+        }
+    }
+    private void startHeartBeatTimer() {
+        if (heartBeatTimer != null) {
+            heartBeatTimer.cancel();
+        }
+        
+        heartBeatTimer = new Timer();
+        heartBeatTimer.schedule(new TimerTask() {
+            @Override
+            public void run() {
+                if (iconREDFlag) {
+                    heartBeatLabel.setIcon(new ImageIcon(getClass().getResource("/bg/grey_dot.png")));
+                    iconREDFlag = false;
+                } else {
+                    heartBeatLabel.setIcon(new ImageIcon(getClass().getResource("/bg/green_dot.png")));
+                    iconREDFlag = true;
+                }
+            }
+
+        }, 100, 1000);
+    }
+
+    private void startPlcStatusTimer() {
+        if (plcStatusTimer != null) {
+            plcStatusTimer.cancel();
+        }
+        plcStatusTimer = new Timer();
+        long initialDelay = 500L + Math.abs(gw == null ? 0 : gw.hashCode() % 2000);
+        plcStatusTimer.schedule(new TimerTask() {
+            @Override
+            public void run() {
+                refreshPlcStatus();
+            }
+        }, initialDelay, PLC_STATUS_REFRESH_INTERVAL_MS);
+    }
+
+    private void refreshPlcStatus() {
+        if (stationConfig == null) {
+            return;
+        }
+        long now = System.currentTimeMillis();
+        if (now < nextPlcStatusReadTime) {
+            return;
+        }
+        try {
+            final PLCUtils.StationStatus status = PLCUtils.readStationStatus(stationConfig);
+            plcStatusReadFailCount = 0;
+            nextPlcStatusReadTime = 0L;
+            SwingUtilities.invokeLater(new Runnable() {
+                @Override
+                public void run() {
+                    setPlcStatusDot("allowStart", status.isAllowStart());
+                    setPlcStatusDot("allowDown", status.isAllowDown());
+                    setPlcStatusDot("start", status.isStart());
+                    setPlcStatusDot("finish", status.isFinish());
+                    setPlcStatusDot("fault", status.isFault());
+                }
+            });
+        } catch (Exception e) {
+            plcStatusReadFailCount++;
+            nextPlcStatusReadTime = now + PLC_STATUS_RETRY_BACKOFF_MS;
+            if (now - lastPlcStatusWarnTime >= PLC_STATUS_WARN_INTERVAL_MS) {
+                lastPlcStatusWarnTime = now;
+                log.warn("读取PLC状态失败，工位={}，连续失败{}次，{}ms后重试", gw, plcStatusReadFailCount, PLC_STATUS_RETRY_BACKOFF_MS, e);
+            }
+        }
+    }
+
+    private void startGetCurSn(){
+        if (getSnBeatTimer != null) {
+            getSnBeatTimer.cancel();
+        }
+        getSnBeatTimer = new Timer();
+        getSnBeatTimer.schedule(new TimerTask() {
+            @Override
+            public void run() {
+                runWorkFlowSafely();
+            }
+
+        }, 100, 1000);
+    }
+
+    private void runWorkFlowSafely() {
+        long now = System.currentTimeMillis();
+        if (now < nextPlcWorkflowTime) {
+            return;
+        }
+        try {
+            runWorkFlow();
+            plcWorkflowFailCount = 0;
+            nextPlcWorkflowTime = 0L;
+        } catch (Exception e) {
+            handleWorkflowException(e);
+        }
+    }
+
+    private void runWorkFlow() {
+        if (workStatus == 1) {
+            if (plcStatus == 0){
+                // 等待扫码
+                String sn = productSnField.getText().trim();
+                if (!sn.isEmpty()) {
+                    plcStatus = 1;
+                }
+            } else if (plcStatus == 1) {
+                // 质量检查合格后，发送允许启动信号。
+                Boolean ret = PLCUtils.writeStartMethod(stationConfig);
+                if (ret) {
+                    statusLabel.setForeground(Color.GREEN);
+                    statusLabel.setText("已允许启动，等待开始加工");
+                    plcStatus = 2;
+                }
+            } else if (plcStatus == 2) {
+                // 等待开始加工信号为 true，收到后将允许启动置为 false。
+                Boolean ret = PLCUtils.readStartMethod(stationConfig);
+                System.out.println("开始加工信号"+stationConfig.getGw()+ret);
+                if (ret){
+                    boolean ret2 = PLCUtils.writeStopMethod(stationConfig);
+                    if (ret2) {
+                        startWeldingParamSampler();
+                        statusLabel.setForeground(Color.GREEN);
+                        statusLabel.setText("加工中，等待加工结束");
+                        plcStatus = 3;
+                    }
+                }
+            } else if (plcStatus ==3) {
+                // 等待加工结束信号为 true，提交结果后发送允许下料信号。
+                Boolean ret = PLCUtils.readStopMethod(stationConfig);
+                if (ret){
+                    // 发送结果
+                    String sn = productSnField.getText().trim();
+                    if (lastWeldingParamContent == null || lastWeldingParamContent.trim().isEmpty()) {
+                        lastWeldingParamContent = stopWeldingParamSamplerAndGetContent();
+                        log.info("PLC中读取"+lastWeldingParamContent);
+                    }
+                    JSONObject retObj = DataUtil.sendQuality( sn,"OK", currentUser, gw, lineSn, serverIp);
+                    if (retObj != null && "true".equalsIgnoreCase(retObj.getString("result"))) {
+                        if (lastWeldingParamContent != null && !lastWeldingParamContent.trim().isEmpty()) {
+                            JSONObject saveParamRet = DataUtil.saveWeldingParams(sn, gw, lineSn, serverIp, lastWeldingParamContent);
+                            if (saveParamRet == null || !"true".equalsIgnoreCase(saveParamRet.getString("result"))) {
+                                log.warn("焊接参数上传失败，工位={}, 工件码={}", gw, sn);
+                            }
+                        }
+                        Boolean downRet = PLCUtils.writeDownMethod(stationConfig);
+                        if (downRet) {
+                            statusLabel.setForeground(Color.GREEN);
+                            statusLabel.setText("已允许下料，等待加工结束信号复位");
+                            finishOkButton.setEnabled(false);
+                            finishNgButton.setEnabled(false);
+                            plcStatus = 4;
+                        }
+                    } else {
+                        statusLabel.setForeground(Color.RED);
+                        String msg = (retObj != null && retObj.containsKey("message")) ? retObj.getString("message") : "提交失败";
+                        statusLabel.setText(msg);
+                    }
+                }
+            }else if (plcStatus == 4){
+                // 等待加工结束信号为 false，收到后将允许下料置为 false。
+                Boolean ret = PLCUtils.readStopMethod(stationConfig);
+                if (!ret){
+                    PLCUtils.writeDownStopMethod(stationConfig);
+                    resetState();
+                }
+            }
+
+            return;
+        } else if (workStatus == 0) {
+            JSONObject result = DataUtil.getCurSn(gw, serverIp, lineSn);
+            // 正常处理结果
+            if (result.containsKey("data")) {
+                String data = result.getString("data");
+                if (data != null && !data.isEmpty()) {
+                    productSnField.setText(data);
+                    checkQuality(data);
+                } else {
+                    JOptionPane.showMessageDialog(WorkStationPanel.this, "获取工件码为空", "提示", JOptionPane.INFORMATION_MESSAGE);
+                }
+            }
+        }
+    }
+
+    private void handleWorkflowException(Exception e) {
+        plcWorkflowFailCount++;
+        long now = System.currentTimeMillis();
+        long retryDelay = Math.min(30000L, 3000L * plcWorkflowFailCount);
+        nextPlcWorkflowTime = now + retryDelay;
+        if (now - lastPlcWorkflowWarnTime >= PLC_WORKFLOW_WARN_INTERVAL_MS) {
+            lastPlcWorkflowWarnTime = now;
+            log.warn("PLC自动流程执行失败，工位={}，流程状态={}，连续失败{}次，下次继续等待", gw, plcStatus, plcWorkflowFailCount, e);
+        }
+    }
+
+
+    private void startWeldingParamSampler() {
+        if (stationConfig == null || weldingParamSampler != null) {
+            return;
+        }
+        lastWeldingParamContent = "";
+        weldingParamSampler = PLCUtils.startWeldingParamSampler(stationConfig);
+        log.info("start welding param sampler, gw={}", gw);
+    }
+
+    private String stopWeldingParamSamplerAndGetContent() {
+        PLCUtils.WeldingParamSampler sampler = weldingParamSampler;
+        weldingParamSampler = null;
+        String content;
+        if (sampler == null) {
+            content = PLCUtils.getWeldingParamContent(stationConfig);
+        } else {
+            content = sampler.stopAndGetContent();
+        }
+        hjparams = new ArrayList<>();
+        if (content != null && !content.trim().isEmpty()) {
+            hjparams.add(content);
+        }
+        log.info("stop welding param sampler, gw={}, contentLength={}", gw, content == null ? 0 : content.length());
+        return content;
+    }
+
+    private void stopWeldingParamSampler() {
+        PLCUtils.WeldingParamSampler sampler = weldingParamSampler;
+        weldingParamSampler = null;
+        if (sampler != null) {
+            sampler.stopAndGetContent();
+        }
+    }
+
+    public void setCurrentUser(String user) {
+        this.currentUser = user;
+    }
+
+    private void showCheckRecordDialog() {
+        JDialog dialog = new JDialog((Frame) SwingUtilities.getWindowAncestor(this), 
+            gw + " - 点检记录", true);
+        dialog.setSize(1000, 600);
+        dialog.setLocationRelativeTo(this);
+        
+        String url = "http://" + serverIp + ":8980/js/a/mes/mesProcessCheckRecord/ulist?ucode=" + currentUser + "&oprno=" + gw + "&lineSn=" + lineSn;
+        MesWebView checkPanel = new MesWebView(url);
+        checkPanel.setSize(990, 550);
+        dialog.add(checkPanel);
+        
+        dialog.setVisible(true);
+    }
+
+    private void showWorkRecordDialog() {
+        JDialog dialog = new JDialog((Frame) SwingUtilities.getWindowAncestor(this), 
+            gw + " - 工作记录", true);
+        dialog.setSize(1000, 600);
+        dialog.setLocationRelativeTo(this);
+        
+        String url = "http://" + serverIp + ":8980/js/a/mes/mesProductRecord/work?oprno=" + gw + "&lineSn=" + lineSn;
+        MesWebView workRecordPanel = new MesWebView(url);
+        workRecordPanel.setSize(990, 550);
+        dialog.add(workRecordPanel);
+        
+        dialog.setVisible(true);
+    }
+}

src/com/mes/util/Base64Utils.java

@@ -0,0 +1,11 @@
+package com.mes.util;
+
+import org.apache.commons.codec.binary.Base64;
+
+public class Base64Utils {
+	public static String getBase64(String str) {
+        byte[] binaryData = str.getBytes();
+        String encodedString = Base64.encodeBase64String(binaryData);
+        return encodedString;
+	}
+}

src/com/mes/util/DateLocalUtils.java

@@ -0,0 +1,32 @@
+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,53 @@
+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("CS")) {
+                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 = "工件码重复";
+            }else if(processMsgRet.equalsIgnoreCase("AL")) {
+                lmsg = "该工件存在未处理的报警信息";
+            } else if (processMsgRet.equalsIgnoreCase("PZ")) {
+                lmsg = "该工件未拍照";
+            } else if (processMsgRet.equalsIgnoreCase("CS")) {
+                lmsg = "超时";
+            }
+        }catch (Exception e){ }
+        return lmsg;
+    }
+}

src/com/mes/util/HttpUtils.java

@@ -0,0 +1,157 @@
+package com.mes.util;
+
+import java.io.*;
+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=GBK");  
+            //允许写出
+            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=GBK");
+            //允许写出
+            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;
+    }
+
+    public static String sendPostRequestJson(String apiUrl, String jsonData) throws IOException {
+        URL url = new URL(apiUrl);
+        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+        conn.setRequestMethod("POST");
+        conn.setRequestProperty("Content-Type", "application/json");
+        conn.setDoOutput(true);
+
+        // 发送请求数据
+        try (OutputStream os = conn.getOutputStream()) {
+            byte[] input = jsonData.getBytes("utf-8");
+            os.write(input, 0, input.length);
+        }
+
+        // 获取响应数据
+        StringBuilder response = new StringBuilder();
+        int responseCode = conn.getResponseCode();
+//        System.out.println("Sending POST request to URL: " + apiUrl);
+//        System.out.println("Post parameters: " + jsonData);
+//        System.out.println("Response Code: " + responseCode);
+
+        try (BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"))) {
+            String responseLine;
+            while ((responseLine = br.readLine()) != null) {
+                response.append(responseLine.trim());
+            }
+        }
+
+        conn.disconnect();
+        return response.toString();
+    }
+
+}

src/com/mes/util/JdbcUtils.java

@@ -0,0 +1,145 @@
+package com.mes.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+public class JdbcUtils {
+	public static final Logger log =  LoggerFactory.getLogger(JdbcUtils.class);
+	//通过上面的工具就可以获取到properties文件中的键值从而可以加载驱动 获取链接 从而 可以增删改查
+	public static Connection conn = null;
+    public static String Drivde="org.sqlite.JDBC";
+	public static String DATABASE_URL="jdbc:sqlite:mes_db.db";
+    
+    public static Connection getConn(){
+        try {
+            Class.forName(Drivde);// 加载驱动,连接sqlite的jdbc
+            conn = DriverManager.getConnection(DATABASE_URL);//连接数据库zhou.db,不存在则创建
+            System.out.println("连接到SQLite数据库成功！");
+            create_bw_record();//初始化结构表
+            //create_measure_data();//初始化测试数据表
+        } catch (Exception e) {
+            // TODO Auto-generated catch block
+        	close();//关闭数据库连接
+            e.printStackTrace();
+        }
+        return conn;
+    }
+
+	public static void openConnection() {
+		try {
+			Class.forName(Drivde);// 加载驱动,连接sqlite的jdbc
+			conn = DriverManager.getConnection(DATABASE_URL);
+		} catch (ClassNotFoundException e) {
+			e.printStackTrace();
+		} catch (SQLException e) {
+			e.printStackTrace();
+			// 如果连接失败，尝试重连
+			reconnect();
+		}
+	}
+
+	private static void reconnect() {
+		try {
+			// 关闭旧连接
+			if (conn != null && !conn.isClosed()) {
+				conn.close();
+			}
+			// 重新建立连接
+			conn = DriverManager.getConnection(DATABASE_URL);
+		} catch (SQLException e) {
+			e.printStackTrace();
+			// 如果重连失败，可以进一步处理异常，比如记录日志、通知管理员等
+		}
+	}
+    
+    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);
+
+		// 创建 提交记录表
+		String submitRecord = "CREATE TABLE if not exists submit_record(\n" +
+				"   id INTEGER PRIMARY KEY AUTOINCREMENT, -- 自增ID\n" +
+				"   oprno VARCHAR(20),                    -- 工位号 \n" +
+				"   sn VARCHAR(48),                       -- 二维码\n" +
+				"   bw VARCHAR(1000),                     -- 报文 \n" +
+				"   record_time DATETIME,                 -- 记录时间\n" +
+				"   state CHAR(1)      -- 状态(0 ->未提交, 1 ->已提交)\n" +
+				")";
+		statement.executeUpdate(submitRecord);
+
+        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();
+		try {
+			// 确保连接已经打开
+			if (JdbcUtils.conn == null || JdbcUtils.conn.isClosed()) {
+				JdbcUtils.openConnection();
+			}
+			//创建连接对象，是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;
+    }
+
+	// 向 submit_record表 插入提交记录数据
+	public static boolean insertSubmitRecord(String oprno, String sn, String bw){
+		boolean ret = false;
+		String record_time = DateLocalUtils.getCurrentTime();
+		try {
+			// 确保连接已经打开
+			if (JdbcUtils.conn == null || JdbcUtils.conn.isClosed()) {
+				JdbcUtils.openConnection();
+			}
+			Statement statement=conn.createStatement();
+			String insertSQL = "INSERT INTO submit_record (oprno, sn, bw, record_time, state)" +
+					"VALUES('" + oprno + "', '" + sn + "', '" + bw + "', '" + record_time + "', '0')";
+			statement.executeUpdate(insertSQL);
+			statement.close();
+			ret = true;
+			log.info("向submit_record表插入数据成功: {}", insertSQL);
+		} catch (SQLException e) {
+			ret = false;
+			log.info("向submit_record表插入数据失败");
+		}
+		return ret;
+	}
+
+    
+    public static void close(){
+        try {
+        	if(conn!=null) {
+        		conn.close();
+        	}
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+    
+    
+
+}
+ 
+

src/com/mes/util/PLCPointTestMain.java

@@ -0,0 +1,585 @@
+package com.mes.util;
+
+import com.github.xingshuangs.iot.protocol.melsec.enums.EMcSeries;
+import com.github.xingshuangs.iot.protocol.melsec.service.McPLC;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.Scanner;
+
+public class PLCPointTestMain {
+
+    private static final int Q26_PORT = 8000;
+    private static final int FX5U_SLMP_PORT = 5001;
+    private static final int CONNECT_TIMEOUT_MS = 2000;
+    private static final List<StationPoint> STATIONS = new ArrayList<>();
+
+    static {
+        STATIONS.add(StationPoint.spot("OP40", "192.168.0.35", Q26_PORT, EMcSeries.QnA,
+                "M6601", "M6602", "M6603", "M6604", "M6605",
+                "M6700", "M6750", "M6800", "M6850",
+                "D7001", "D7002", "D7051", "D7061", "D7052", "D7062"));
+        STATIONS.add(StationPoint.bitOnly("OP70", "192.168.0.35", Q26_PORT, EMcSeries.QnA,
+                "M6611", "M6612", "M6613", "M6614", "M6615",
+                "M6900", "M6950", "M7000", "M7050"));
+        STATIONS.add(StationPoint.spot("OP30", "192.168.0.35", Q26_PORT, EMcSeries.QnA,
+                "M6621", "M6622", "M6623", "M6624", "M6625",
+                "M7100", "M7150", "M7200", "M7250",
+                "D7003", "D7004", "D7071", "D7081", "D7072", "D7082"));
+        STATIONS.add(StationPoint.bitOnly("OP80", "192.168.0.35", Q26_PORT, EMcSeries.QnA,
+                "M6631", "M6632", "M6633", "M6634", "M6635",
+                "M7300", "M7350", "M7400", "M7450"));
+        STATIONS.add(StationPoint.spot("OP20", "192.168.0.35", Q26_PORT, EMcSeries.QnA,
+                "M6641", "M6642", "M6643", "M6644", "M6645",
+                "M7500", "M7550", "M7600", "M7650",
+                "D7005", "D7006", "D7091", "D7101", "D7092", "D7102"));
+        STATIONS.add(StationPoint.bitOnly("OP90", "192.168.0.35", Q26_PORT, EMcSeries.QnA,
+                "M6651", "M6652", "M6653", "M6654", "M6655",
+                "M7700", "M7750", "M7800", "M7850"));
+        STATIONS.add(StationPoint.arc("OP10", "192.168.0.35", Q26_PORT, EMcSeries.QnA,
+                "M6661", "M6662", "M6663", "M6664", "M6665",
+                "4号机器人", "D7041", "D7042",
+                "3号机器人", "D7031", "D7032"));
+        STATIONS.add(StationPoint.simple("OP100", "192.168.0.35", Q26_PORT, EMcSeries.QnA,
+                "M6671", "M6672", "M6673", "M6674", "M6675"));
+        STATIONS.add(StationPoint.arc("OP120", "192.168.0.35", Q26_PORT, EMcSeries.QnA,
+                "M6681", "M6682", "M6683", "M6684", "M6685",
+                "2号机器人", "D7021", "D7022",
+                "1号机器人", "D7011", "D7012"));
+        STATIONS.add(StationPoint.simple("OP110", "192.168.0.35", Q26_PORT, EMcSeries.QnA,
+                "M6691", "M6692", "M6693", "M6694", "M6695"));
+
+        // 192.168.0.10 是 SLMP 通讯，现场测试 5001 端口可读。
+        STATIONS.add(StationPoint.spot("OP50", "192.168.0.10", FX5U_SLMP_PORT, EMcSeries.Q_L,
+                "M6001", "M6002", "M6003", "M6004", "M6005",
+                "M6100", "M6150", "M6300", "M6350",
+                "D6001", "D6011", "D6002", "D6012", "D6003", "D6013"));
+        STATIONS.add(StationPoint.bitOnly("OP60", "192.168.0.10", FX5U_SLMP_PORT, EMcSeries.Q_L,
+                "M6011", "M6012", "M6013", "M6014", "M6015",
+                "M6200", "M6250", "M6400", "M6450"));
+    }
+
+    public static void main(String[] args) {
+        System.out.println("PLC点位测试工具启动：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
+        System.out.println("说明：输入工位号读取该工位点位；输入 ALL 读取全部；输入 Q 退出。");
+        printStationList();
+
+        Scanner scanner = new Scanner(System.in);
+        while (true) {
+            System.out.println();
+            System.out.print("请输入要测试的工位号，例如 OP40 / OP50 / ALL / Q：");
+            String input = scanner.nextLine();
+            if (input == null) {
+                continue;
+            }
+
+            String command = input.trim().toUpperCase(Locale.ROOT);
+            if (command.isEmpty()) {
+                continue;
+            }
+            if ("Q".equals(command) || "QUIT".equals(command) || "EXIT".equals(command)) {
+                System.out.println("已退出PLC点位测试。");
+                break;
+            }
+            if ("ALL".equals(command) || "全部".equals(command)) {
+                for (StationPoint station : STATIONS) {
+                    testStation(station);
+                }
+                continue;
+            }
+
+            StationPoint station = findStation(command);
+            if (station == null) {
+                System.out.println("未找到工位：" + command);
+                printStationList();
+                continue;
+            }
+
+            handleStation(scanner, station);
+        }
+    }
+
+    private static void handleStation(Scanner scanner, StationPoint station) {
+        while (true) {
+            System.out.println();
+            System.out.println("已选择工位：" + station.code + "（PLC：" + station.ip + ":" + station.port
+                    + "，系列：" + station.series + "，允许启动点位：" + station.allowStart + "）");
+            System.out.println("请选择操作：");
+            System.out.println("  1：读取该工位全部点位");
+            System.out.println("  2：手动写允许启动 = true");
+            System.out.println("  3：手动写允许启动 = false");
+            System.out.println("  4：测试该PLC常见端口");
+            System.out.println("  5：临时修改该工位PLC端口");
+            System.out.println("  6：临时切换该工位PLC系列");
+            System.out.println("  7：诊断允许启动写入方式");
+            System.out.println("  B：返回工位选择");
+            System.out.print("请输入：");
+
+            String input = scanner.nextLine();
+            if (input == null) {
+                continue;
+            }
+            String command = input.trim().toUpperCase(Locale.ROOT);
+            if (command.isEmpty()) {
+                continue;
+            }
+            if ("B".equals(command) || "BACK".equals(command)) {
+                return;
+            }
+            if ("1".equals(command) || "R".equals(command) || "READ".equals(command) || "读取".equals(command)) {
+                testStation(station);
+            } else if ("2".equals(command) || "T".equals(command) || "TRUE".equals(command)) {
+                writeAllowStart(station, true);
+            } else if ("3".equals(command) || "F".equals(command) || "FALSE".equals(command)) {
+                writeAllowStart(station, false);
+            } else if ("4".equals(command) || "PORT".equals(command)) {
+                testPorts(station.ip);
+            } else if ("5".equals(command) || "SETPORT".equals(command)) {
+                changeStationPort(scanner, station);
+            } else if ("6".equals(command) || "SETSERIES".equals(command)) {
+                changeStationSeries(scanner, station);
+            } else if ("7".equals(command) || "WRITEDEBUG".equals(command)) {
+                diagnoseAllowStartWrite(scanner, station);
+            } else {
+                System.out.println("输入无效，请输入 1 / 2 / 3 / 4 / 5 / 6 / 7 / B。");
+            }
+        }
+    }
+
+    private static void testStation(StationPoint station) {
+        printStationTitle(station);
+        printPlcConnectTip(station);
+
+        McPLC plc = createPlc(station);
+        try {
+            plc.setConnectTimeout(CONNECT_TIMEOUT_MS);
+            plc.setReceiveTimeout(3000);
+
+            readBoolean(plc, "允许启动", station.allowStart);
+            readBoolean(plc, "允许下料", station.allowDown);
+            readBoolean(plc, "开始加工", station.start);
+            readBoolean(plc, "加工结束", station.finish);
+            readBoolean(plc, "故障", station.fault);
+
+            if ("spot".equals(station.type) || "bitOnly".equals(station.type)) {
+                readBooleanRange(plc, "1号机器人焊接开始", station.robot1Start, 50);
+                readBooleanRange(plc, "1号机器人焊接完成", station.robot1Done, 50);
+                readBooleanRange(plc, "2号机器人焊接开始", station.robot2Start, 50);
+                readBooleanRange(plc, "2号机器人焊接完成", station.robot2Done, 50);
+            }
+
+            if ("spot".equals(station.type)) {
+                readInt16(plc, "1号机器人压力", station.robot1Pressure);
+                readInt16(plc, "2号机器人压力", station.robot2Pressure);
+                readScaledInt16(plc, "1号机器人焊接电流(A)", station.robot1Current, 100, false);
+                readScaledInt16(plc, "2号机器人焊接电流(A)", station.robot2Current, 100, false);
+                readScaledInt16(plc, "1号机器人焊接时间(ms)", station.robot1Time, 20, true);
+                readScaledInt16(plc, "2号机器人焊接时间(ms)", station.robot2Time, 20, true);
+            } else if ("arc".equals(station.type)) {
+                readInt16(plc, station.upperRobotName + "电流", station.upperCurrent);
+                readScaledInt16(plc, station.upperRobotName + "电压(V)", station.upperVoltage, 10, false);
+                readInt16(plc, station.lowerRobotName + "电流", station.lowerCurrent);
+                readScaledInt16(plc, station.lowerRobotName + "电压(V)", station.lowerVoltage, 10, false);
+            }
+        } finally {
+            plc.close();
+        }
+    }
+
+    private static void writeAllowStart(StationPoint station, boolean value) {
+        System.out.println();
+        System.out.println("准备写入：" + station.code + " 允许启动 " + station.allowStart + " = " + value);
+        printPlcConnectTip(station);
+
+        McPLC plc = createPlc(station);
+        try {
+            plc.setConnectTimeout(CONNECT_TIMEOUT_MS);
+            plc.setReceiveTimeout(3000);
+
+            System.out.println("写入方式：单点写。");
+            System.out.println("  " + station.allowStart + " = " + value);
+            plc.writeBoolean(station.allowStart, value);
+            System.out.println("写入命令已完成，正在重新连接读取确认：");
+        } catch (Exception e) {
+            printError("允许启动写入", station.allowStart, e);
+        } finally {
+            plc.close();
+        }
+
+        sleep(300);
+        confirmAllowStart(station);
+    }
+
+    private static void diagnoseAllowStartWrite(Scanner scanner, StationPoint station) {
+        System.out.println();
+        System.out.println("写入诊断会直接写 " + station.allowStart + "，请确认设备处于允许测试状态。");
+        System.out.print("请输入要写入的值 true / false，或输入 B 返回：");
+        String input = scanner.nextLine();
+        if (input == null) {
+            return;
+        }
+        String command = input.trim().toUpperCase(Locale.ROOT);
+        if ("B".equals(command) || "BACK".equals(command)) {
+            return;
+        }
+        if (!"TRUE".equals(command) && !"FALSE".equals(command)) {
+            System.out.println("输入无效，本次不写入。");
+            return;
+        }
+
+        boolean value = Boolean.parseBoolean(command.toLowerCase(Locale.ROOT));
+        System.out.println("诊断目标：" + station.code + " " + station.ip + ":" + station.port
+                + "，系列：" + station.series + "，点位：" + station.allowStart + " = " + value);
+
+        System.out.println();
+        System.out.println("步骤1：写入前读取确认。");
+        confirmAllowStart(station);
+
+        System.out.println();
+        System.out.println("步骤2：单点写入测试。");
+        writeAllowStartSingle(station, value);
+        sleep(800);
+        confirmAllowStart(station);
+
+        System.out.println();
+        System.out.println("步骤3：连续2个位写入测试。");
+        writeAllowStartBatch(station, value);
+        sleep(800);
+        confirmAllowStart(station);
+
+        System.out.println();
+        System.out.println("诊断说明：如果单点写成功、连续写失败，菜单2/3应使用单点写；说明该PLC不适合用连续位写方式操作允许启动。");
+    }
+
+    private static void writeAllowStartSingle(StationPoint station, boolean value) {
+        printPlcConnectTip(station);
+        McPLC plc = createPlc(station);
+        try {
+            plc.setConnectTimeout(CONNECT_TIMEOUT_MS);
+            plc.setReceiveTimeout(3000);
+            System.out.println("  单点写：" + station.allowStart + " = " + value);
+            plc.writeBoolean(station.allowStart, value);
+            System.out.println("  单点写命令已完成。");
+        } catch (Exception e) {
+            printError("单点写允许启动", station.allowStart, e);
+        } finally {
+            plc.close();
+        }
+    }
+
+    private static void writeAllowStartBatch(StationPoint station, boolean value) {
+        printPlcConnectTip(station);
+        McPLC plc = createPlc(station);
+        try {
+            plc.setConnectTimeout(CONNECT_TIMEOUT_MS);
+            plc.setReceiveTimeout(3000);
+            boolean allowDownNow = plc.readBoolean(station.allowDown);
+            System.out.println("  连续写2个位：" + station.allowStart + " = " + value
+                    + "，" + station.allowDown + " = " + allowDownNow + "（保持原值）");
+            plc.writeBoolean(station.allowStart, Arrays.asList(value, allowDownNow));
+            System.out.println("  连续写命令已完成。");
+        } catch (Exception e) {
+            printError("连续写允许启动", station.allowStart, e);
+        } finally {
+            plc.close();
+        }
+    }
+
+    private static void confirmAllowStart(StationPoint station) {
+        McPLC plc = createPlc(station);
+        try {
+            plc.setConnectTimeout(CONNECT_TIMEOUT_MS);
+            plc.setReceiveTimeout(3000);
+            readBoolean(plc, "允许启动确认", station.allowStart);
+            readBoolean(plc, "允许下料确认", station.allowDown);
+        } catch (Exception e) {
+            printError("写入后确认读取", station.allowStart, e);
+        } finally {
+            plc.close();
+        }
+    }
+
+    private static McPLC createPlc(StationPoint station) {
+        return new McPLC(station.series, station.ip, station.port);
+    }
+
+    private static void printPlcConnectTip(StationPoint station) {
+        System.out.println("准备通过SLMP/MC连接PLC：" + station.ip + ":" + station.port
+                + "，系列：" + station.series + "，超时 " + CONNECT_TIMEOUT_MS + "ms ...");
+    }
+
+    private static boolean checkConnection(String ip, int port) {
+        System.out.println("正在连接PLC：" + ip + ":" + port + "，超时 " + CONNECT_TIMEOUT_MS + "ms ...");
+        try (Socket socket = new Socket()) {
+            socket.connect(new InetSocketAddress(ip, port), CONNECT_TIMEOUT_MS);
+            System.out.println("PLC连接成功。");
+            return true;
+        } catch (IOException e) {
+            System.out.println("PLC连接失败：" + e.getMessage());
+            System.out.println("请检查：IP能ping通不等于SLMP/MC端口可用，需要确认PLC开放的TCP端口。");
+            return false;
+        }
+    }
+
+    private static void testPorts(String ip) {
+        int[] ports = {5000, 5001, 5002, 8000};
+        System.out.println("开始测试 " + ip + " 的常见SLMP/MC端口...");
+        for (int port : ports) {
+            boolean ok = checkConnection(ip, port);
+            System.out.println("  " + ip + ":" + port + " -> " + (ok ? "通" : "不通"));
+        }
+    }
+
+    private static void changeStationPort(Scanner scanner, StationPoint station) {
+        System.out.println("当前工位 " + station.code + " 端口=" + station.port);
+        System.out.print("请输入新端口，例如 5000 / 5001 / 8000：");
+        String input = scanner.nextLine();
+        try {
+            int port = Integer.parseInt(input.trim());
+            station.port = port;
+            System.out.println("已将 " + station.code + " 端口改为 " + port + "，可立即输入 1 读取测试。");
+        } catch (Exception e) {
+            System.out.println("端口输入无效。");
+        }
+    }
+
+    private static void changeStationSeries(Scanner scanner, StationPoint station) {
+        System.out.println("当前工位 " + station.code + " 系列=" + station.series);
+        System.out.println("可选：1=QnA，2=Q_L，3=IQ_R");
+        System.out.print("请输入：");
+        String input = scanner.nextLine();
+        if ("1".equals(input.trim())) {
+            station.series = EMcSeries.QnA;
+        } else if ("2".equals(input.trim())) {
+            station.series = EMcSeries.Q_L;
+        } else if ("3".equals(input.trim())) {
+            station.series = EMcSeries.IQ_R;
+        } else {
+            System.out.println("系列输入无效。");
+            return;
+        }
+        System.out.println("已将 " + station.code + " 系列改为 " + station.series + "，可立即输入 1 读取测试。");
+    }
+
+    private static void readBoolean(McPLC plc, String name, String address) {
+        try {
+            System.out.printf("  %-24s %-12s = %s%n", name, address, toChineseBoolean(plc.readBoolean(address)));
+        } catch (Exception e) {
+            printError(name, address, e);
+        }
+    }
+
+    private static void readBooleanRange(McPLC plc, String name, String startAddress, int count) {
+        try {
+            List<Boolean> values = plc.readBoolean(startAddress, count);
+            System.out.printf("  %-24s %-12s 置位数量=%d 明细=%s%n",
+                    name, formatBitRange(startAddress, count), countTrue(values), toChineseBooleanList(values));
+        } catch (Exception e) {
+            printError(name, startAddress, e);
+        }
+    }
+
+    private static void readInt16(McPLC plc, String name, String address) {
+        try {
+            System.out.printf("  %-24s %-12s = %d%n", name, address, plc.readInt16(address));
+        } catch (Exception e) {
+            printError(name, address, e);
+        }
+    }
+
+    private static void readScaledInt16(McPLC plc, String name, String address, int factor, boolean multiply) {
+        try {
+            short raw = plc.readInt16(address);
+            double value = multiply ? raw * factor : raw * 1.0 / factor;
+            String formula = multiply ? "原始值*" + factor : "原始值/" + factor;
+            System.out.printf(Locale.ROOT, "  %-24s %-12s 原始值=%d 换算值=%.2f（%s）%n",
+                    name, address, raw, value, formula);
+        } catch (Exception e) {
+            printError(name, address, e);
+        }
+    }
+
+    private static StationPoint findStation(String stationCode) {
+        for (StationPoint station : STATIONS) {
+            if (station.code.equalsIgnoreCase(stationCode)) {
+                return station;
+            }
+        }
+        return null;
+    }
+
+    private static void printStationList() {
+        System.out.println("可测试工位：");
+        for (StationPoint station : STATIONS) {
+            System.out.println("  " + station.code + "（PLC：" + station.ip + ":" + station.port
+                    + "，系列：" + station.series + "，类型：" + station.typeName() + "）");
+        }
+    }
+
+    private static int countTrue(List<Boolean> values) {
+        int count = 0;
+        for (Boolean value : values) {
+            if (Boolean.TRUE.equals(value)) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    private static String formatBitRange(String startAddress, int count) {
+        String prefix = startAddress.substring(0, 1);
+        int start = Integer.parseInt(startAddress.substring(1));
+        return prefix + start + "-" + prefix + (start + count - 1);
+    }
+
+    private static String toChineseBoolean(boolean value) {
+        return value ? "有信号(true)" : "无信号(false)";
+    }
+
+    private static String toChineseBooleanList(List<Boolean> values) {
+        StringBuilder sb = new StringBuilder("[");
+        for (int i = 0; i < values.size(); i++) {
+            if (i > 0) {
+                sb.append(",");
+            }
+            sb.append(Boolean.TRUE.equals(values.get(i)) ? "1" : "0");
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+
+    private static void printStationTitle(StationPoint station) {
+        System.out.println();
+        System.out.println("============================================================");
+        System.out.println("开始读取：" + station.code + "，PLC：" + station.ip + ":" + station.port
+                + "，系列：" + station.series + "，类型：" + station.typeName());
+        System.out.println("============================================================");
+    }
+
+    private static void printError(String name, String address, Exception e) {
+        System.out.printf("  %-24s %-12s 操作失败：%s%n", name, address, e.getMessage());
+    }
+
+    private static void sleep(long millis) {
+        try {
+            Thread.sleep(millis);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private static class StationPoint {
+        String code;
+        String ip;
+        int port;
+        EMcSeries series;
+        String type;
+        String allowStart;
+        String allowDown;
+        String start;
+        String finish;
+        String fault;
+        String robot1Start;
+        String robot1Done;
+        String robot2Start;
+        String robot2Done;
+        String robot1Pressure;
+        String robot2Pressure;
+        String robot1Current;
+        String robot2Current;
+        String robot1Time;
+        String robot2Time;
+        String upperRobotName;
+        String upperCurrent;
+        String upperVoltage;
+        String lowerRobotName;
+        String lowerCurrent;
+        String lowerVoltage;
+
+        static StationPoint simple(String code, String ip, int port, EMcSeries series,
+                                   String allowStart, String allowDown, String start,
+                                   String finish, String fault) {
+            return base(code, ip, port, series, "simple", allowStart, allowDown, start, finish, fault);
+        }
+
+        static StationPoint bitOnly(String code, String ip, int port, EMcSeries series,
+                                    String allowStart, String allowDown, String start,
+                                    String finish, String fault, String robot1Start, String robot1Done,
+                                    String robot2Start, String robot2Done) {
+            StationPoint point = base(code, ip, port, series, "bitOnly", allowStart, allowDown, start, finish, fault);
+            point.robot1Start = robot1Start;
+            point.robot1Done = robot1Done;
+            point.robot2Start = robot2Start;
+            point.robot2Done = robot2Done;
+            return point;
+        }
+
+        static StationPoint spot(String code, String ip, int port, EMcSeries series,
+                                 String allowStart, String allowDown, String start,
+                                 String finish, String fault, String robot1Start, String robot1Done,
+                                 String robot2Start, String robot2Done, String robot1Pressure, String robot2Pressure,
+                                 String robot1Current, String robot2Current, String robot1Time, String robot2Time) {
+            StationPoint point = bitOnly(code, ip, port, series, allowStart, allowDown, start, finish, fault,
+                    robot1Start, robot1Done, robot2Start, robot2Done);
+            point.type = "spot";
+            point.robot1Pressure = robot1Pressure;
+            point.robot2Pressure = robot2Pressure;
+            point.robot1Current = robot1Current;
+            point.robot2Current = robot2Current;
+            point.robot1Time = robot1Time;
+            point.robot2Time = robot2Time;
+            return point;
+        }
+
+        static StationPoint arc(String code, String ip, int port, EMcSeries series,
+                                String allowStart, String allowDown, String start,
+                                String finish, String fault, String upperRobotName, String upperCurrent,
+                                String upperVoltage, String lowerRobotName, String lowerCurrent, String lowerVoltage) {
+            StationPoint point = base(code, ip, port, series, "arc", allowStart, allowDown, start, finish, fault);
+            point.upperRobotName = upperRobotName;
+            point.upperCurrent = upperCurrent;
+            point.upperVoltage = upperVoltage;
+            point.lowerRobotName = lowerRobotName;
+            point.lowerCurrent = lowerCurrent;
+            point.lowerVoltage = lowerVoltage;
+            return point;
+        }
+
+        private static StationPoint base(String code, String ip, int port, EMcSeries series, String type,
+                                         String allowStart, String allowDown,
+                                         String start, String finish, String fault) {
+            StationPoint point = new StationPoint();
+            point.code = code;
+            point.ip = ip;
+            point.port = port;
+            point.series = series;
+            point.type = type;
+            point.allowStart = allowStart;
+            point.allowDown = allowDown;
+            point.start = start;
+            point.finish = finish;
+            point.fault = fault;
+            return point;
+        }
+
+        String typeName() {
+            if ("spot".equals(type)) {
+                return "点焊";
+            }
+            if ("arc".equals(type)) {
+                return "弧焊";
+            }
+            if ("bitOnly".equals(type)) {
+                return "焊点信号";
+            }
+            return "基础信号";
+        }
+    }
+}