mesclient-auto3/src/com/mes/component/WorkJPanelOP70.java

package com.mes.component;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.github.xingshuangs.iot.protocol.s7.enums.EPlcType;
import com.github.xingshuangs.iot.protocol.s7.service.S7PLC;
import com.mes.ui.CacheData;
import com.mes.ui.DataUtil;
import com.mes.ui.MesClient;
import com.mes.util.JdbcUtils;
import com.mes.util.TCPClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class WorkJPanelOP70 extends JPanel {
   //70AC，AB同时发送上料请求，导致A无法再次响应码
    public static final Logger log =  LoggerFactory.getLogger(WorkJPanelOP70.class);

    public String oprno = "OP080"; // 原OP070封板反面FSW，产线改造后工位号OP080

    public String pos = "A";

    public String lastSn = ""; // 最近的码

    public String lineSn = "CZ060";

    public JLabel feedinglabel;

    public JLabel feedingmeslabel;

    public JLabel runlabel; //运行反馈，

    public JLabel blankinglabel; // 下料反馈

    public JLabel blankingmeslabel; // 下料MES反馈

    public JLabel feedingtodevicelabel; // 上料到设备

    public JLabel feedingtotransferlabel; // 上料到中转车

    public JLabel transfertodevicelabel; // 上料到中转车

    public JButton scanBtn;

    public JTextField productSn;

    public JTextField productSnFeeding;

    public JButton status_menu;

    public JButton resetBtn;

    public JButton resetFeedingBtn;

    public ImageIcon imageGreen;

    public ImageIcon imageGray;

    public String plcIp1 = "192.168.90.85"; // plc5 西侧
    public String plcIp2 = "192.168.90.86"; // plc6 东侧


    public Integer errflag2 = 0;

    public S7PLC s7PLC = null;

    public Integer workWidth = 470;
    public Integer workHeight = 300;

    public String plcDb = "";

    public String plcDb2 = "DB7010";

    public String preSn = ""; // 扫码内容

    public Integer tjFeedingFlag = 0; // 上料状态标识
    public Integer tjFlag = 0; // 1=可加工 2=设备运行中 3=加工结束
    public Integer tjStatus = 0; // 提交标识
    public Integer sbtjStatus = 0; // 提交标识
    public Boolean toDevice = false;
    public Boolean toTransfer = false;
    public Boolean transferToDevice = false;

    public Boolean plcHeart = false;

    public Integer isLocal = 0; // 0=正式 1=本地

    public Integer isScan = 1; // 1=西侧 2=东测

    public String finallySn = "";

    public String fswDeviceName = "";

    public JLabel oprnoLabel;

    public JLabel oprnoLabel2;

    public JButton signalBtn; // 信号监控按钮

    public PlcSignalMonitor signalMonitor; // 信号监控组件

    public CacheData cacheData = null;

    public String cacheName = "";

    public WorkJPanelOP70(String position){
        this.setLayout(null);
        this.setBackground(Color.WHITE);
        this.pos = position;

        cacheName = "cache_"+oprno+pos;

        cacheData = JdbcUtils.getCache(cacheName);
        if(cacheData == null){
            cacheData = new CacheData();
            cacheData.setLastSn("");
            cacheData.setSn("");
            cacheData.setFeedingSn("");
            cacheData.setTjStatus(0);
            cacheData.setTjFlag(0);
            cacheData.setError(-1);
            cacheData.setMsg("");
            JdbcUtils.setCache(cacheName,JSON.toJSONString(cacheData));
        }

        if(MesClient.mes_line_pos.equals("east")){ // 东侧
            s7PLC = new S7PLC(EPlcType.S1500, plcIp2);
            isScan = 2;
        }else{
            s7PLC = new S7PLC(EPlcType.S1500, plcIp1);
            isScan = 1;
        }

        s7PLC.setConnectTimeout(1000);
        s7PLC.setReceiveTimeout(1000);

        // 设备DB对照：反面FSW1=DB7002、反面FSW2=DB7003
        // 原3号机、4号机已取消，C/F位不再实例化
        if(pos.equals("A")){
            plcDb = "DB7002";
            fswDeviceName = "西侧1号机";
        }else if(pos.equals("B")){
            plcDb = "DB7003";
            fswDeviceName = "西侧2号机";
        }else if(pos.equals("D")){
            plcDb = "DB7002";
            fswDeviceName = "东侧1号机";
        }else if(pos.equals("E")){
            plcDb = "DB7003";
            fswDeviceName = "东侧2号机";
        }

        oprnoLabel = new JLabel(oprno+pos);
        oprnoLabel.setHorizontalAlignment(SwingConstants.CENTER);
        oprnoLabel.setForeground(Color.BLACK);
        oprnoLabel.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        oprnoLabel.setBounds(0, -10, workWidth/5, 40);
        this.add(oprnoLabel);

        oprnoLabel2 = new JLabel(fswDeviceName);
        oprnoLabel2.setHorizontalAlignment(SwingConstants.CENTER);
        oprnoLabel2.setForeground(Color.BLACK);
        oprnoLabel2.setFont(new Font("微软雅黑", Font.PLAIN, 14));
        oprnoLabel2.setBounds(0, 12, workWidth / 5, 40);
        this.add(oprnoLabel2);

        status_menu = new JButton("等待请求扫码");
        status_menu.setBounds(workWidth/5, 0, workWidth*4/5, 40);
        status_menu.setForeground(Color.GREEN);
        status_menu.setForeground(Color.GREEN);
        status_menu.setFont(new Font("微软雅黑", Font.PLAIN, 16));
        status_menu.setBackground(Color.BLACK);
        this.add(status_menu);

        JLabel oprnoLabelFeeding = new JLabel("上料");
        oprnoLabelFeeding.setHorizontalAlignment(SwingConstants.CENTER);
        oprnoLabelFeeding.setForeground(Color.BLACK);
        oprnoLabelFeeding.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        oprnoLabelFeeding.setBounds(0, 50, workWidth/5, 40);
        this.add(oprnoLabelFeeding);

        productSnFeeding = new JTextField("");
        productSnFeeding.setHorizontalAlignment(SwingConstants.CENTER);
        productSnFeeding.setForeground(Color.BLACK);
        productSnFeeding.setFont(new Font("微软雅黑", Font.PLAIN, 16));
        productSnFeeding.setEditable(false);
        productSnFeeding.setBounds(workWidth/5, 50, workWidth*3/5, 40);
        productSnFeeding.addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                String sn = productSnFeeding.getText().trim();
                if(!sn.isEmpty()){
                    MesClient.createQRCode(productSnFeeding.getText(),oprno+pos);
                }
            }
        });
        this.add(productSnFeeding);

        JLabel oprnoLabelWork = new JLabel("加工");
        oprnoLabelWork.setHorizontalAlignment(SwingConstants.CENTER);
        oprnoLabelWork.setForeground(Color.BLACK);
        oprnoLabelWork.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        oprnoLabelWork.setBounds(0, 100, workWidth/5, 40);
        this.add(oprnoLabelWork);

        productSn = new JTextField("");
        productSn.setHorizontalAlignment(SwingConstants.CENTER);
        productSn.setForeground(Color.BLACK);
        productSn.setFont(new Font("微软雅黑", Font.PLAIN, 16));
        productSn.setEditable(false);
        productSn.setBounds(workWidth/5, 100, workWidth*3/5, 40);
        productSn.addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                String sn = productSn.getText().trim();
                if(!sn.isEmpty()){
                    MesClient.createQRCode(productSn.getText(),oprno+pos);
                }
            }
        });
        this.add(productSn);

        resetFeedingBtn = new JButton("刷新");
        resetFeedingBtn.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                int choice = JOptionPane.showConfirmDialog(null, "确定刷新上料工件吗？", "操作确认", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
                if (choice == JOptionPane.YES_OPTION) {
                    resetFeeding();
                }
            }
        });
        resetFeedingBtn.setFont(new Font("微软雅黑", Font.PLAIN, 22));
        resetFeedingBtn.setBounds(workWidth*4/5 + 10, 50, workWidth/5 - 10, 40);
        this.add(resetFeedingBtn);

        resetBtn = new JButton("刷新");
        resetBtn.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                int choice = JOptionPane.showConfirmDialog(null, "确定刷新加工工件吗？", "操作确认", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
                if (choice == JOptionPane.YES_OPTION) {
                    resetBlanking();
                }
            }
        });
        resetBtn.setFont(new Font("微软雅黑", Font.PLAIN, 22));
        resetBtn.setBounds(workWidth*4/5 + 10, 100, workWidth/5 - 10, 40);
        this.add(resetBtn);

        imageGreen = new ImageIcon(MesClient.class.getResource("/bg/green_dot.png"));
        imageGreen.setImage(imageGreen.getImage().getScaledInstance(20, 20, Image.SCALE_SMOOTH));

        imageGray = new ImageIcon(MesClient.class.getResource("/bg/grey_dot.png"));
        imageGray.setImage(imageGray.getImage().getScaledInstance(20, 20, Image.SCALE_SMOOTH));

        // 信号灯布局：2列×4行，名称后显示PLC点位
        feedinglabel = new JLabel(withAddr("请求扫码", plcDb+".0.0"));
        feedinglabel.setHorizontalAlignment(SwingConstants.LEFT);
        feedinglabel.setIcon(imageGreen);
        feedinglabel.setForeground(Color.BLACK);
        feedinglabel.setBounds(0, 145, workWidth/2, 27);
        this.add(feedinglabel);

        feedingmeslabel = new JLabel(withAddr("MES扫码反馈", plcDb+".0.4"));
        feedingmeslabel.setHorizontalAlignment(SwingConstants.LEFT);
        feedingmeslabel.setIcon(imageGreen);
        feedingmeslabel.setForeground(Color.BLACK);
        feedingmeslabel.setBounds(workWidth/2, 145, workWidth/2, 27);
        feedingmeslabel.addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                boolean ret = readAllowFeeding();
                int choice = JOptionPane.showConfirmDialog(null, "确定修改MES扫码反馈结果为"+(ret?"false":"true")+"吗？", "操作确认", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
                if (choice == JOptionPane.YES_OPTION) {
                    writeAllowFeeding(!ret);
                }
            }
        });
        this.add(feedingmeslabel);

        runlabel = new JLabel(withAddr("设备运行中", plcDb+".0.2"));
        runlabel.setHorizontalAlignment(SwingConstants.LEFT);
        runlabel.setIcon(imageGreen);
        runlabel.setForeground(Color.BLACK);
        runlabel.setBounds(0, 199, workWidth/2, 27);
        this.add(runlabel);

        blankinglabel = new JLabel(withAddr("下料请求", plcDb+".0.1"));
        blankinglabel.setHorizontalAlignment(SwingConstants.LEFT);
        blankinglabel.setIcon(imageGreen);
        blankinglabel.setForeground(Color.BLACK);
        blankinglabel.setBounds(0, 172, workWidth/2, 27);
        this.add(blankinglabel);

        blankingmeslabel = new JLabel(withAddr("MES下料反馈", plcDb+".0.5"));
        blankingmeslabel.setHorizontalAlignment(SwingConstants.LEFT);
        blankingmeslabel.setIcon(imageGreen);
        blankingmeslabel.setForeground(Color.BLACK);
        blankingmeslabel.setBounds(workWidth/2, 172, workWidth/2, 27);
        this.add(blankingmeslabel);
        blankingmeslabel.addMouseListener(new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                boolean ret = readAllowBlanking();
                int choice = JOptionPane.showConfirmDialog(null, "确定修改MES下料反馈结果为"+(ret?"false":"true")+"吗？", "操作确认", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);
                if (choice == JOptionPane.YES_OPTION) {
                    writeAllowBlanking(!ret);
                }
            }
        });

        feedingtodevicelabel = new JLabel(withAddr("上料到设备", plcDb+".0.7"));
        feedingtodevicelabel.setHorizontalAlignment(SwingConstants.LEFT);
        feedingtodevicelabel.setIcon(imageGreen);
        feedingtodevicelabel.setForeground(Color.BLACK);
        feedingtodevicelabel.setBounds(workWidth/2, 199, workWidth/2, 27);
        this.add(feedingtodevicelabel);

        feedingtotransferlabel = new JLabel(withAddr("上料到中转车", plcDb+".1.0"));
        feedingtotransferlabel.setHorizontalAlignment(SwingConstants.LEFT);
        feedingtotransferlabel.setIcon(imageGreen);
        feedingtotransferlabel.setForeground(Color.BLACK);
        feedingtotransferlabel.setBounds(0, 226, workWidth/2, 27);
        this.add(feedingtotransferlabel);

        transfertodevicelabel = new JLabel(withAddr("中转车上料到设备", plcDb+".1.1"));
        transfertodevicelabel.setHorizontalAlignment(SwingConstants.LEFT);
        transfertodevicelabel.setIcon(imageGreen);
        transfertodevicelabel.setForeground(Color.BLACK);
        transfertodevicelabel.setBounds(workWidth/2, 226, workWidth/2, 27);
        this.add(transfertodevicelabel);

        formatElementUI();

        startOprnoTimer();
        heartData();

        // 信号监控按钮
        signalMonitor = new PlcSignalMonitor(s7PLC, plcDb, oprno + pos, MesClient.mesClientFrame);
        signalBtn = signalMonitor.createSignalButton();
        signalBtn.setBounds(workWidth*2/3 + 63, 255, 90, 26); // 信号灯改为4行后下移
        this.add(signalBtn);



//        resetScanA();

        monitorDeviceStatus();
    }

    public void formatElementUI(){
        cacheData = JdbcUtils.getCache(cacheName);
        if(cacheData == null){
            return;
        }
        String msg = cacheData.getMsg();
        int error = cacheData.getError();
        String sn = cacheData.getSn();
        productSn.setText(sn);

        String feedingSn = cacheData.getFeedingSn();
        productSnFeeding.setText(feedingSn);

        tjFlag = cacheData.getTjFlag();
        lastSn = cacheData.getLastSn();

        setMenuStatus(msg,error);

        this.repaint();
    }

    public void setMenuStatus(String msg,int error){
        if(error == 0){
            this.status_menu.setForeground(Color.GREEN);
        }else{
            this.status_menu.setForeground(Color.RED);
        }
        this.status_menu.setText(msg);

        cacheData.setMsg(msg);
        cacheData.setError(error);
        cacheData.setTjFlag(tjFlag);
        cacheData.setTjStatus(tjStatus);
        cacheData.setLastSn(lastSn);
        cacheData.setSn(productSn.getText());
        cacheData.setFeedingSn(productSnFeeding.getText());
        JdbcUtils.setCache(cacheName, JSON.toJSONString(cacheData));
    }

    // 定时任务 -----------------------------------------------------------------------------------------------------

    public Timer cjTimerText2;
    public void heartData() {
        if(cjTimerText2!=null) {
            cjTimerText2.cancel();
        }
        cjTimerText2 = new Timer();
        cjTimerText2.schedule(new TimerTask() {
            public void run() {
                if(MesClient.isLogin == 1 && isLocal == 0){
                    plcHeart = !plcHeart;
                    writeBoolean(plcDb+".0.6",plcHeart);
                }
            }
        }, 1000,1000);
    }

    public Timer cjTimerText3;
    public void monitorDeviceStatus() {
        if(cjTimerText3!=null) {
            cjTimerText3.cancel();
        }
        cjTimerText3 = new Timer();
        cjTimerText3.schedule(new TimerTask() {
            public void run() {
                if(MesClient.isLogin == 1 && isLocal == 0){
                    try{
                        int ret = getAlarm();
                        if(ret == 0){
                            errflag2 = 0;
                        }
                        if(ret != 0 && errflag2 == 0 ){
                            String content = oprno+pos;
                            if(ret == 1){
                                content += "安全门故障";
                            }else if(ret == 2){
                                content += "急停故障";
                            }else if(ret == 3){
                                content += "光栅故障";
                            }else if(ret == 4){
                                content += "夹紧故障";
                            }

                            errflag2 = 1;
                            DataUtil.deviceAlarm(oprno+pos,productSn.getText(),content,MesClient.user_menu.getText());
                        }
                    }catch (Exception e){

                    }
                }
            }
        }, 1000,1000);
    }

    public Timer oprnoTimer;
    public void startOprnoTimer() {

        //心跳显示图标
        if(oprnoTimer!=null) {
            oprnoTimer.cancel();
        }
        oprnoTimer = new Timer();
        oprnoTimer.schedule(new TimerTask() {
            public void run() {
                try{

                    if(MesClient.isLogin == 1){
                        Boolean retFeeding = readFeeding();
                        feedinglabel.setIcon(retFeeding?imageGreen:imageGray);

                        transferToDevice = readFeedingTransferToDevice();
                        transfertodevicelabel.setIcon(transferToDevice?imageGreen:imageGray);

                        Boolean retFeedingAllow = readAllowFeeding();
                        feedingmeslabel.setIcon(retFeedingAllow?imageGreen:imageGray);

                        if(!retFeeding && retFeedingAllow){
                            writeAllowFeeding(false);
                        }

                        Boolean retBlanking = readBlanking(); //请求下料
                        blankinglabel.setIcon(retBlanking?imageGreen:imageGray);

                        Boolean retAllowBlanking = readAllowBlanking();    //MES 允许下料
                        blankingmeslabel.setIcon(retAllowBlanking?imageGreen:imageGray);

                        toDevice = readFeedingToDevice();     //目标是否为设备
                        feedingtodevicelabel.setIcon(toDevice?imageGreen:imageGray);

                        toTransfer = readFeedingToTransfer();    //目标是否为中转车
                        feedingtotransferlabel.setIcon(toTransfer?imageGreen:imageGray);

                        transferToDevice = readFeedingTransferToDevice();     //中专车到设备
                        transfertodevicelabel.setIcon(transferToDevice?imageGreen:imageGray);

                        Boolean retRunning = readRunning();    //设备是否运行
                        runlabel.setIcon(retRunning?imageGreen:imageGray);

                        /**
                         * 1.70xh会进行扫码并给反馈
                         * 2.执行上料，从mesclient中获取全局码，并给上料反馈
                         * */

                        //如果允许下料，但未输入条码，则允许下料
                        if(retBlanking && productSn.getText().isEmpty()){
                            writeAllowBlanking(true);
                            resetBlanking();
                        }


                        //上料
                        if(tjFeedingFlag == 0){
                            if(retFeeding){   //读取上料信号
                                barCode();     //获取全局码，并给上料反馈
                            }
                            if(retRunning){
                                resetFeeding();
                            }
                        }else if(tjFeedingFlag == 1){
//                            if(toDevice){ // 去设备
                                if(tjFlag == 0 && retRunning){
                                    tjFlag = 1;
                                    productSn.setText(productSnFeeding.getText());
//                                    resetBtn.setEnabled(false);
                                    resetFeeding();
                                }
                        }

                        if(tjFlag == 0 && !retBlanking){
                            writeAllowBlanking(false);
                        }

                        if(tjFlag == 1){
//                            if(toDevice){ // 去设备
                                if(retRunning){
                                    tjFlag = 2;
                                    setMenuStatus("工件加工中", 0);
                                    // 运行中清除下料反馈
                                    writeAllowBlanking(false);
                                }
//                            }
                        }else if(tjFlag == 2){
                            if(retBlanking){
                                tjFlag = 3;
                                setMenuStatus("工件加工结束，结果上传中", 0);

                                if(sbtjStatus == 0){
                                    sbtjStatus = 1;
                                    log.info("开始上传结果:"+productSn.getText()+" oprno:"+oprno+pos);
                                    JSONObject retObj = DataUtil.sendQuality(productSn.getText(),oprno+pos,"OK",MesClient.user_menu.getText());
                                    if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
                                        resetBlanking();
                                    }else{
                                        if(retObj.get("result")==null){
                                            log.info("结果上传失败result为null:"+productSn.getText()+" oprno:"+oprno+pos);
                                            setMenuStatus("请求失败，请重试",-1);
                                        }else{
                                            if(retObj.get("result").toString().equalsIgnoreCase("false")){
                                                log.info("结果上传失败:"+retObj.getString("message"));
                                                setMenuStatus(retObj.getString("message"),-1);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }



                }catch (Exception e) {
                    log.error(e.getMessage());
                }
            }
        }, 100,1500);
    }

    public void barCode2(){
        String sn = "";
        if(isScan == 1){
            sn = MesClient.scanQrcode2();
        }else{
            sn = MesClient.scanQrcode3();
        }
        preSn = sn.trim();
        log.info("preSn:"+preSn);
        MesClient.setMenuStatus("工件码："+sn, 0);
        if(sn.length() != WorkJPanel70Xh.SN_LENGTH){
//            MesClient.setMenuStatus("扫码结果为空", -1);
        }else{
            finallySn = sn;   //全局码
            productSnFeeding.setText(sn);
//            writeScanFinish(true);
        }
    }
    public void barCode(){

        //如果为空则不进行上料
        if(!productSnFeeding.getText().isEmpty()){
            return;
        }

        String sn = readQrcode();
        if(sn.equals("")){
            if(productSnFeeding.getText().isEmpty()){
                productSnFeeding.setText("空结果");
                this.setMenuStatus("扫码结果为空", -1);
            }
        }else{
            productSnFeeding.setText(sn);
            lastSn = sn;

            // 查询工件质量
            JSONObject retObj = DataUtil.checkQuality(sn,oprno+pos,MesClient.user_menu.getText());
            if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
                tjFeedingFlag = 1;//可加工
                setMenuStatus("工件可以加工", 0);
                writeAllowFeeding(true);    //允许上料
//                resetFeedingBtn.setEnabled(false);
            }else{
                writeAllowFeeding(false);
                resetFeedingBtn.setEnabled(true);
                if(retObj.get("result")==null){
                    setMenuStatus("请求失败，请重试",-1);
                }else{
                    if(retObj.get("result").toString().equalsIgnoreCase("false")){
                        setMenuStatus(retObj.getString("message"),-1);
                    }
                }
            }
        }
    }

    public void resetBlanking() {
        tjFlag = 0;
        tjStatus = 0;
        sbtjStatus = 0;
        productSn.setText("");
        setMenuStatus("工件结果已提交，等待下一件",0);
        resetBtn.setEnabled(true);
//        writeAllowFeeding(false);
//        writeAllowBlanking(false);
    }

    public void resetFeeding() {
        productSnFeeding.setText("");
        tjFeedingFlag = 0;
        setMenuStatus("等待请求扫码",0);
        resetFeedingBtn.setEnabled(true);
        writeAllowFeeding(false);
    }

    public void resetScanA() {
        tjFeedingFlag = 0;
        tjFlag = 0;
        tjStatus = 0;
        productSn.setText("");
        productSnFeeding.setText("");
        setMenuStatus("等待请求扫码",0);
        resetBtn.setEnabled(true);
        resetFeedingBtn.setEnabled(true);

        if(isLocal == 0){
            writeAllowFeeding(false);
            writeAllowBlanking(false);
        }
    }


    //原来的扫码为上料


    // 与设备交互-----------------------------------------------------------------------------------------
    // 请求扫码
    public boolean readScanFeeding(){
        if(isLocal == 1){
            return false;
        }else{
            return readBoolean(plcDb2+".0.0");  //7002 扫码
        }
    }
    // 扫码完成
    public boolean readScanFinish(){
        if(isLocal == 1){
            return false;
        }else{
            return readBoolean(plcDb2+".0.1");   //扫码完成
        }
    }

    // 扫码完成反馈
    public boolean writeScanFinish(boolean bt){
        if(isLocal == 1){
            return false;
        }else{
            return writeBoolean(plcDb2+".0.1",bt);
        }
    }


    // 请求扫码
    public boolean readFeeding(){
        if(isLocal == 1){
            return false;
        }else{
            return readBoolean(plcDb+".0.0");
        }
    }

    // 读取上料到设备
    public boolean readFeedingToDevice(){
        if(isLocal == 1){
            return true;
        }else{
            return readBoolean(plcDb+".0.7");
        }
    }

    // 读取上料到中转车
    public boolean readFeedingToTransfer(){
        if(isLocal == 1){
            return true;
        }else{
            return readBoolean(plcDb+".1.0");
        }
    }

    // 读取中转车上料到设备
    public boolean readFeedingTransferToDevice(){
        if(isLocal == 1){
            return true;
        }else{
            return readBoolean(plcDb+".1.1");
        }
    }

    // 读取下料信号
    public boolean readBlanking(){
        if(isLocal == 1){
            return false;
        }else{
            return readBoolean(plcDb+".0.1");
        }
    }

    // 读取设备运行信号
    public boolean readRunning(){
        if(isLocal == 1){
            return true;
        }else{
            return readBoolean(plcDb+".0.2");
        }
    }

    // 读取设备通讯状态
    public boolean readDeviceStatus(){
        if(isLocal == 1){
            return true;
        }else{
            return readBoolean(plcDb+".0.3");
        }
    }

    // 读取MES允许上料信号
    public boolean readAllowFeeding(){
        if(isLocal == 1){
            return false;
        }else{
            return readBoolean(plcDb+".0.4");
        }
    }

    // 写入MES允许上料信号
    public boolean writeAllowFeeding(Boolean b){
        if(isLocal == 1){
            return true;
        }else{
            return writeBoolean(plcDb+".0.4",b);
        }
    }

    // 读取MES允许下料信号
    public boolean readAllowBlanking(){
        if(isLocal == 1){
            return true;
        }else{
            return readBoolean(plcDb+".0.5");
        }
    }

    // 写入MES允许下料信号
    public boolean writeAllowBlanking(Boolean b){
        if(isLocal == 1){
            return true;
        }else{
            return writeBoolean(plcDb+".0.5",b);
        }
    }

    // 读取中转车号
    public int readTransferNo(){
        if(isLocal == 1){
            return 1;
        }else{
            return s7PLC.readInt16(plcDb+".2.0");
        }
    }

    // 读取中转车层数
    public int readTransferFloor(){
        if(isLocal == 1){
            return 1;
        }else{
            return s7PLC.readInt16(plcDb+".4.0");
        }
    }

    // 信号灯文字：名称(点位)
    private String withAddr(String name, String addr){
        return name + "(" + addr + ")";
    }

    // 控制扫码枪读取二维码
    public String readQrcode(){
//        String sn = "5001040043561010006";
        String sn = "";
//        String sn = finallySn;
        if(isLocal == 1){
            return "";
        }else{
            return MesClient.workJPanel70Xh.productSnFeeding.getText().trim();
        }

//        return sn;
    }

    public boolean readBoolean(String db){
        boolean permit;
        try {
            permit = s7PLC.readBoolean(db);
//            log.info("<"+this.oprno+this.pos+">读取"+db+"-->成功，结果：{}", permit ? "true" : "false");
        } catch (Exception e) {
            log.error("<"+this.oprno+this.pos+">读取"+db+"-->失败", e);
            return false;
        }
        return permit;
    }

    public boolean writeBoolean(String db, boolean permit){
        try {
            s7PLC.writeBoolean(db,permit);
//            log.info("<"+this.oprno+this.pos+">写入"+db+"-->成功，写入内容：{}", permit ? "true" : "false");
        } catch (Exception e) {
//            log.error("<"+this.oprno+this.pos+">写入"+db+"-->失败，写入内容：{}", permit ? "true" : "false");
            log.error(e.getMessage(), e);
            return false;
        }
        return true;
    }

    public int getAlarm(){
        boolean ret0 = readBoolean(plcDb+".6.0");
        if(ret0){
            return 1;
        }
        boolean ret1 = readBoolean(plcDb+".6.1");
        if(ret1){
            return 2;
        }
        boolean ret2 = readBoolean(plcDb+".6.2");
        if(ret2){
            return 3;
        }
        boolean ret4 = readBoolean(plcDb+".6.3");
        if(ret4){
            return 4;
        }
        return 0;

    }

}