Java OPC 代碼

本文轉載自查看原文 2018-08-17 20:22 3626 OPC

這是我項目的代碼，算是真實業務實現，記錄備份一下實現思路
因為業務就是簡單的獲取數據然后保存，所以還是容易理解的

1.任務詳情

Java實現OPC通信的代碼實現

最終實現對西門子的S7-300的PLC變量的值讀寫

2.實現情況

使用utgard實現通信：Java實現OPC通信

OPCserver：KEPserver6

配置DCOM：OPC和DCOM配置

制定變量列表：規定名稱和類型

說明

PC和PLC通信，PC用TAG1之類的地址，PLC用BD1.INT05之類的地址，個人總結的表格，方便說明

OPCServer上定義的地址名稱	硬件PLC上的地址	數據類型	說明：這個地址做什么用的
TAG1	DB1.INT00	short	心跳
TAG2	DB1.INT02	short	控制字
TAG3	DB1.STRING4,10	string	箱體信息
TAG4	DB1.D14	float	結果

地址定義在OPCServer上，實際截圖

制定交互流程：控制字的狀態

心跳變量：TAG1，表示軟件和硬件(這里是PLC)連接狀態，這個是自己隨便定義的，我的是：PLC一直寫1，PC收到1寫2，5秒內一直收不到1就是斷開了。

控制字(狀態變量)：TAG2，作用是作為一個控制字，控制整個交互的流程，當是不同值時，PLC和PC要進行指定的讀寫動作。

這是我一開始畫的

這是后來畫的，就是PC和PLC的交互，比較清晰了

實際的PLC地址編輯界面截圖

3. 代碼實現

按照官方例子寫了一個通信類：通過配置信息，啟動server，添加要讀取的地址

配置信息是單獨一個類：從配置文件讀取IP什么的

然后是回調函數：某個地址，讀到了某個值要怎么做，，在這就2個回調，心跳TAG1：讀到1寫入2，5秒超時，TAG2：是某個值時，怎么做。。。

讀值和寫值可以單獨算一個方法類：我用到的數據類型就是幾個，short，string，Long Array，對應寫了幾個方法

OPCServer上的地址配置也算是一個單獨的類：我寫在配置文件了，當時猶豫是不是放到數據庫，感覺差別不大

Utgard有兩種數據訪問方式——直接通過item的read/write方法或者使用AccessBase（讀取數據）

心跳TAG1：PC寫2，PLC寫1，邏輯是PC收到1寫2，超時提示

控制字TAG2：PLC寫0,1,3,4,5,6/7，PC寫2,8

PC在寫TAG2=1時，同時寫入TAG3值

PLC在寫TAG2=6/7時，同時寫入TAG4值

讀線程：每隔500ms讀一次值，讀到值后執行回調方法DataCallback()

不用另起線程，直接用這個Access線程循環讀取控制字的值，回調方法對應調用item的read/write方法讀寫值

final AccessBase access = new SyncAccess(server, 500);
access.addItem(itemId, new DataCallback() {
    @Override
    public void changed(Item item, ItemState state) {
        System.out.println("-----" + state);
    }
});
// start reading
access.bind();

4.代碼：OPCserver連接配置類

import java.io.IOException;
import java.util.Properties;
import org.openscada.opc.lib.common.ConnectionInformation;
/**
 * 配置文件工具類
 */
public final class OPCConfiguration {
    private final static ConnectionInformation ci;
    private final static Properties prop;
    public final static String CONFIG_USERNAME = "username";
    public final static String CONFIG_PASSWORD = "password";
    public final static String CONFIG_HOST = "host";
    public final static String CONFIG_DOMAIN = "domain";
    public final static String CONFIG_CLSID = "clsid";
    public final static String CONFIG_PROGID = "progid";
    private final static String CONFIG_FILE_NAME = "opc.properties";
    /**
     * 加載配置文件
     */
    static {
        ci = new ConnectionInformation();
        prop = new Properties();
        try {
            prop.load(OPCConfiguration.class.getClassLoader().getResourceAsStream(CONFIG_FILE_NAME));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 通過名字獲得配置的值
     */
    public static String getEntryValue(String name) {
        return prop.getProperty(name);
    }
    /**
     * 獲得包含ClsId的連接信息
     */
    public static ConnectionInformation getCLSIDConnectionInfomation() {
        ci.setProgId(null);
        getConnectionInfomation();
        ci.setClsid(prop.getProperty(CONFIG_CLSID));
        return ci;
    }
    /**
     * 獲得包含ProgId的連接信息
     */
    public static ConnectionInformation getPROGIDConnectionInfomation() {
        ci.setClsid(null);
        getConnectionInfomation();
        ci.setProgId(prop.getProperty(CONFIG_PROGID));
        return ci;
    }
    /**
     * 獲得基礎的連接信息
     */
    private static void getConnectionInfomation() {
        ci.setHost(prop.getProperty(CONFIG_HOST));
        ci.setDomain(prop.getProperty(CONFIG_DOMAIN));
        ci.setUser(prop.getProperty(CONFIG_USERNAME));
        ci.setPassword(prop.getProperty(CONFIG_PASSWORD));
    }
}

5.代碼：通信實現類

package cn.com.tcb.assembly.management.listener;
import static cn.com.tcb.assembly.management.listener.OPCConfiguration.getCLSIDConnectionInfomation;
import java.util.concurrent.Executors;
import org.jinterop.dcom.common.JIException;
import org.openscada.opc.lib.common.ConnectionInformation;
import org.openscada.opc.lib.da.AccessBase;
import org.openscada.opc.lib.da.Group;
import org.openscada.opc.lib.da.Item;
import org.openscada.opc.lib.da.Server;
import org.openscada.opc.lib.da.SyncAccess;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * 功能：OPC通信線程 描述：通過循環讀取心跳和狀態控制字，按照商議好的交互流程讀寫變量
 */
public class OPCComm {
    private static Logger logger = LoggerFactory.getLogger(OPCComm.class);
    private Item item_heartbeat;
    private Item item_status;
    private Item item_ordernum;
    private Item item_sn;
    private Item item_boxnum;
    private Item item_abnormal;
    private Item item_finish;
    private Item item_result;
    private Server server;
    /**
     * 單例模式
     */
    private static class SingletonHolder {
        static final OPCComm doOPCComm = new OPCComm();
    }
    public static OPCComm getInstance() {
        return SingletonHolder.doOPCComm;
    }
    /**
     * 啟動server 創建一個監控線程 創建一個寫入線程
     */
    public void init() throws Exception {
        // 加載配置文件
        final ConnectionInformation ci = getCLSIDConnectionInfomation();
        // 創建server
        final Server server = new Server(ci, Executors.newSingleThreadScheduledExecutor());
        try {
            // 啟動server
            server.connect();
            logger.info("This is {} message.", "OPCserver connect success");
            this.server = server;
            // 同步讀取，500ms一次
            final AccessBase access = new SyncAccess(server, 500);
            access.addItem(OPCElement.ITEMID_HEARTBEAT, new DataCallBack_HeartBeat());
            access.addItem(OPCElement.ITEMID_STATUS, new DataCallBack_Status());
            // 添加一個組
            final Group group = server.addGroup("sew");
            item_heartbeat = group.addItem(OPCElement.ITEMID_HEARTBEAT);
            item_status = group.addItem(OPCElement.ITEMID_STATUS);
            item_ordernum = group.addItem(OPCElement.ITEMID_ORDERNUM);
            item_sn = group.addItem(OPCElement.ITEMID_SN);
            item_boxnum = group.addItem(OPCElement.ITEMID_BOXNUM);
            item_abnormal = group.addItem(OPCElement.ITEMID_ABNORMAL);
            item_finish = group.addItem(OPCElement.ITEMID_FINISH);
            item_result = group.addItem(OPCElement.ITEMID_RESULT);
            // start reading
            access.bind();
        } catch (final JIException e) {
            System.out.println(String.format("%08X: %s", e.getErrorCode(), server.getErrorMessage(e.getErrorCode())));
        }
    }
    public Item getItem_heartbeat() {
        return item_heartbeat;
    }
    public Item getItem_status() {
        return item_status;
    }
    public Item getItem_ordernum() {
        return item_ordernum;
    }
    public Item getItem_sn() {
        return item_sn;
    }
    public Item getItem_boxnum() {
        return item_boxnum;
    }
    public Item getItem_abnormal() {
        return item_abnormal;
    }
    public Item getItem_finish() {
        return item_finish;
    }
    public Item getItem_result() {
        return item_result;
    }
    public Server getServer() {
        return server;
    }
}

6.代碼：工具類：讀寫值

package cn.com.tcb.assembly.management.listener;

import java.text.DecimalFormat;

import org.jinterop.dcom.common.JIException;
import org.jinterop.dcom.core.JIArray;
import org.jinterop.dcom.core.JIVariant;
import org.openscada.opc.lib.da.Item;
import org.openscada.opc.lib.da.ItemState;

public class OPCUnit {

    /**
     * 寫值到變量
     */
    public static void write(Item item, String val) {
        try {
            JIVariant value = new JIVariant(val);
            item.write(value);
        } catch (JIException e) {
            e.printStackTrace();
        }
    }

    /**
     * 寫值到變量:數組
     */
    public static void write(Item item, String[] snArray) {
        try {

            /** 構造寫入數據 */
            Long[] integerData = new Long[snArray.length];
            for (int i = 0; i < snArray.length; i++) {
                integerData[i] = Long.valueOf(snArray[i]);
            }
            final JIArray array = new JIArray(integerData, false);
            final JIVariant value = new JIVariant(array);

            item.write(value);
        } catch (JIException e) {
            e.printStackTrace();
        }
    }

    /**
     * 讀變量的值 如果是short和int直接返回字符串； 如果是long類型的數組,返回數字內容間加點，對應long，數組，大小為6
     * 如果是float類型的數組,返回數字內容間加逗號，對應float，數組，大小為20
     */
    public static String read(Item item) {
        String result = "";
        try {
            ItemState state = item.read(true);
            int type = state.getValue().getType();

            if (type == JIVariant.VT_UI4) {
                int value = state.getValue().getObjectAsInt();
                return value + "";
            } else if (type == JIVariant.VT_I2) {
                short value = state.getValue().getObjectAsShort();
                return value + "";
            } else if (type == 8195) {
                JIArray jarr = state.getValue().getObjectAsArray();
                Integer[] arr = (Integer[]) jarr.getArrayInstance();
                String value = "";
                for (Integer i : arr) {
                    value = value + i + ".";
                }
                String res = value.substring(0, value.length() - 1);
                // "25.36087601.1.1.18.36"-->"25.36087601.01.0001.18.36"
                String[] array = res.split("[.]");
                String ress = array[0] + "." + array[1] + "." + new DecimalFormat("00").format(Long.valueOf(array[2]))
                        + "." + new DecimalFormat("0000").format(Long.valueOf(array[3])) + "." + array[4] + "."
                        + array[5];
                return ress;

            } else if (type == 8196) {
                JIArray jarr = state.getValue().getObjectAsArray();
                Float[] arr = (Float[]) jarr.getArrayInstance();
                String value = "";
                for (Float f : arr) {
                    value = value + f + ",";
                }
                return value.substring(0, value.length() - 1);
            }

        } catch (JIException e) {
            e.printStackTrace();
        }
        return result;
    }

}

7.代碼：回調函數：實現心跳

package cn.com.tcb.assembly.management.listener;
import java.awt.Color;
import org.jinterop.dcom.common.JIException;
import org.jinterop.dcom.core.JIVariant;
import org.openscada.opc.lib.da.DataCallback;
import org.openscada.opc.lib.da.Item;
import org.openscada.opc.lib.da.ItemState;
import cn.com.tcb.assembly.base.core.AppContext;
import cn.com.tcb.assembly.base.utils.GlobalVariable;
import cn.com.tcb.assembly.management.ui.main.MainFrame;
public class DataCallBack_HeartBeat implements DataCallback {
    private OPCComm opc = OPCComm.getInstance();
    private int count = 0;@
    Override
    public void changed(Item item, ItemState state) {
        // 讀取心跳變量的值
        try {
            if (state.getValue().getType() == JIVariant.VT_I2) {
                short n = state.getValue().getObjectAsShort();
                setHeartbeat(n);
            }
        } catch (JIException e) {
            e.printStackTrace();
        }
    }
    /**
     * 設置心跳標志位，保存到全局變量
     */
    public void setHeartbeat(short n) {
        MainFrame main = (MainFrame) AppContext.getParam(GlobalVariable.MAIN_UI);
        if (n == 1) {
            OPCUnit.write(opc.getItem_heartbeat(), "2");
            GlobalVariable.heartbeat = true;
            main.getHeartbeat().setBackground(Color.GREEN);
            count = 0;
        } else {
            count++;
        }
        // 循環讀取頻率是：500ms一次，如果超過6次，也就是3s認定超時
        if (count > 6) {
            GlobalVariable.heartbeat = false;
            main.getHeartbeat().setBackground(Color.RED);
        }
    }
}

8.代碼：回調函數：實現業務

package cn.com.tcb.assembly.management.listener;

import java.awt.Color;

import org.jinterop.dcom.common.JIException;
import org.jinterop.dcom.core.JIVariant;
import org.openscada.opc.lib.da.DataCallback;
import org.openscada.opc.lib.da.Item;
import org.openscada.opc.lib.da.ItemState;
import cn.com.tcb.assembly.base.core.AppContext;
import cn.com.tcb.assembly.base.core.BeanContainer;
import cn.com.tcb.assembly.base.model.JobCard;
import cn.com.tcb.assembly.base.model.TestResult;
import cn.com.tcb.assembly.base.service.JobCardService;
import cn.com.tcb.assembly.base.service.TestResultService;
import cn.com.tcb.assembly.base.utils.GlobalVariable;
import cn.com.tcb.assembly.base.utils.StringUtil;
import cn.com.tcb.assembly.management.ui.main.MainFrame;

/**
 * 根據控制字：向PLC寫入工單信息，保存結果
 */
public class DataCallBack_Status implements DataCallback {
    private OPCComm opc = OPCComm.getInstance();
    private TestResultService testResultService = (TestResultService) BeanContainer.getBean("testResultService");
    private MainFrame main = (MainFrame) AppContext.getParam(GlobalVariable.MAIN_UI);

    @Override
    public void changed(Item item, ItemState itemState) {

        // 讀取狀態變量的值
        try {
            if (itemState.getValue().getType() == JIVariant.VT_I2) {
                short n = itemState.getValue().getObjectAsShort();

                // 前提是有心跳
                if (GlobalVariable.heartbeat) {
                    doProcess(n);
                }
            }
        } catch (JIException e) {
            e.printStackTrace();
        }
    }

    /**
     * 狀態控制字： 0：PLC上電，1：允許新工單，2：新任務，3：收到任務，4：准備執行，5：開始執行 6：正常完成，7：異常玩常完成，8：收到完成信號
     */
    private void doProcess(short n) {
        if (n == 0) {
            setStatus(Color.GREEN, "等待設備初始化");
            GlobalVariable.isAllowInput = true;
        } else if (n == 1) {
            setStatus(Color.GREEN, "請輸入工單");
            GlobalVariable.isAllowInput = true;
        } else if (n == 2) {
            setStatus(Color.GREEN, "發送成功，等待設備處理");
        } else if (n == 3) {
            setStatus(Color.GREEN, "設備收到工單");
            GlobalVariable.isAllowInput = false;
        } else if (n == 4) {
            setStatus(Color.GREEN, "設備准備執行");
            GlobalVariable.isAllowInput = false;
        } else if (n == 5) {
            setStatus(Color.GREEN, "設備開始執行");
            GlobalVariable.isAllowInput = false;
            // 寫入初始結果，記錄開始時間
            if (!GlobalVariable.isHaveOrder) {
                reconnectAction();
            } else {
                saveStartResult();
            }

        } else if (n == 6) {
            setStatus(Color.GREEN, "正常完成");

            // 寫入最終結果，記錄結束時間
            if (!GlobalVariable.isHaveOrder) {
                reconnectAction();
            }
            saveEndResult(OPCControllerState.NORMALEND);

        } else if (n == 7) {
            setStatus(Color.RED, "異常完成");

            // 寫入最終結果，記錄結束時間
            if (!GlobalVariable.isHaveOrder) {
                reconnectAction();
            }
            saveEndResult(OPCControllerState.ABNORMALEND);

        } else if (n == OPCControllerState.SAVESUCCESS) {
            setStatus("結果保存成功");
        } else {
            setStatus(Color.RED, "異常");
        }
    }

    /**
     * 設置主界面狀態信息
     */
    private void setStatus(Color color, String status) {
        main.getStatus().setText(status);
        main.getStatus().setBackground(color);
    }

    private void setStatus(String status) {
        main.getStatus().setText(status);
    }

    /**
     * 保存初始結果:5
     */
    private void saveStartResult() {
        if (!GlobalVariable.isSaveStartSuccess) {
            // 從全局變量獲取結果表
            TestResult t = (TestResult) AppContext.getParam(GlobalVariable.PARAM_KEY_TESTRESULT);

            // 開始時間
            String startTime = testResultService.getDate();
            t.setStartTime(startTime);
            main.getStartTime().setText(startTime);

            // 裝配日期
            t.setDate(startTime.split("[ ]")[0]);

            // 保存結果表到全局變量
            AppContext.setParam(GlobalVariable.PARAM_KEY_TESTRESULT, t);

            // 保存結果到數據庫
            int n = testResultService.getSqlServerCountBySerialNumber(t.getSerialNumber());
            if (n == 0) {
                testResultService.saveResult(t);
            } else {
                testResultService.updateResult(t);
            }

            GlobalVariable.isSaveStartSuccess = true;
        }
    }

    /**
     * 保存最終結果：6或者7
     */
    private void saveEndResult(int n) {
        if (!GlobalVariable.isSaveEndSuccess) {

            // 從全局變量獲取結果表
            TestResult t = (TestResult) AppContext.getParam(GlobalVariable.PARAM_KEY_TESTRESULT);

            // 保存結果到界面
            String endTime = testResultService.getDate();
            t.setEndTime(endTime);
            main.getEndTime().setText(endTime);

            String time = StringUtil.getTimeBetween(t.getStartTime(), endTime);
            t.setTime(time);
            main.getTime().setText(time);

            String value = OPCUnit.read(opc.getItem_result());
            String result = "";
            String[] arr = value.split("[,]");
            result = arr[0] + "-" + arr[1];
            for (int i = 2; i < arr.length; i = i + 2) {
                result = result + dealWith(arr[i], arr[i + 1]);
            }
            main.getResult01().setText(dealWithShow(arr[0], arr[1]));
            main.getResult02().setText(dealWithShow(arr[2], arr[3]));
            main.getResult03().setText(dealWithShow(arr[4], arr[5]));
            main.getResult04().setText(dealWithShow(arr[6], arr[7]));
            main.getResult05().setText(dealWithShow(arr[8], arr[9]));
            main.getResult06().setText(dealWithShow(arr[10], arr[11]));
            main.getResult07().setText(dealWithShow(arr[12], arr[13]));
            main.getResult08().setText(dealWithShow(arr[14], arr[15]));
            main.getResult09().setText(dealWithShow(arr[16], arr[17]));
            main.getResult10().setText(dealWithShow(arr[18], arr[19]));

            t.setResult(result);

            // 異常
            if (n == OPCControllerState.NORMALEND) {
                t.setAbnormal("否");
            } else {
                t.setAbnormal("是");
            }

            // 保存最終結果到數據庫
            testResultService.updateResult(t);

            // 當前工單已經完成
            GlobalVariable.isHaveOrder = false;

            // 寫入狀態字
            OPCUnit.write(opc.getItem_status(), “8”);

            // 讀取成功后不再重復讀取
            GlobalVariable.isSaveEndSuccess = true;
        }
    }

    /**
     * 斷線重連動作
     */
    private void reconnectAction() {
        String sn = OPCUnit.read(opc.getItem_sn());
        // 根據序列號查詢初始保存的結果
        TestResult t = testResultService.getOneDataBySerialNumber(sn);
        AppContext.setParam(GlobalVariable.PARAM_KEY_TESTRESULT, t);

        // 工單恢復
        JobCardService jcs = (JobCardService) BeanContainer.getBean("jobCardService");
        JobCard job = jcs.getJobCardData(t.getOrderNum());
        job.setSerialNumber(t.getSerialNumber());
        AppContext.setParam(GlobalVariable.PARAM_KEY_JOBCARD, job); // 保存工單信息到全局變量

        // 界面恢復
        main.getOrderNumber().setText(t.getOrderNum());
        main.getSn().setText(t.getSerialNumber());
        main.getUnitType().setText(t.getUnitSize());
        main.getBoxNumber().setText(t.getUnitSize().split(" ")[0]);
        main.getSn_count().setText(Integer.parseInt(t.getSerialNumber().split("[.]")[3]) + "");
        main.getCount().setText(job.getCount());
        main.getStartTime().setText(t.getStartTime());

        GlobalVariable.isHaveOrder = true;
    }

    /**
     * 處理結果字符串
     */
    private String dealWith(String str1, String str2) {
        if (str1.equals("0.0") && str2.equals("0.0")) {
            return "";
        }
        return ", " + str1 + "-" + str2;
    }

    private String dealWithShow(String str1, String str2) {
        if (str1.equals("0.0") && str2.equals("0.0")) {
            return "";
        }
        return str1 + "-" + str2;
    }
}

9.配合業務：發送信息到PLC

package cn.com.tcb.assembly.management.action.main;

import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import cn.com.tcb.assembly.base.core.AppContext;
import cn.com.tcb.assembly.base.core.BeanContainer;
import cn.com.tcb.assembly.base.core.LocalDataStore;
import cn.com.tcb.assembly.base.core.ui.PopupDialog;
import cn.com.tcb.assembly.base.core.ui.PopupManager;
import cn.com.tcb.assembly.base.model.JobCard;
import cn.com.tcb.assembly.base.model.TestResult;
import cn.com.tcb.assembly.base.model.User;
import cn.com.tcb.assembly.base.service.TestResultService;
import cn.com.tcb.assembly.base.utils.GlobalVariable;
import cn.com.tcb.assembly.management.listener.OPCComm;
import cn.com.tcb.assembly.management.listener.OPCUnit;
import cn.com.tcb.assembly.management.ui.main.MainFrame;

/**
 * 發送按鈕，發送工單信息到PLC
 */
public class SendAction implements ActionListener {
    private TestResultService testResultService = (TestResultService) BeanContainer.getBean("testResultService");
    private OPCComm opc = OPCComm.getInstance();
    private MainFrame main;

    public SendAction(MainFrame mainFrame) {
        main = mainFrame;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        inputJobCard();
    }

    private void inputJobCard() {

        // 如果設備正在運行，則不允許發送

        // 如果有工單就能發送
        if (GlobalVariable.isHaveOrder) {

            // 從全局變量獲取工單信息
            JobCard job = (JobCard) AppContext.getParam(GlobalVariable.PARAM_KEY_JOBCARD);
            
            // 判定是否重做
            int n = testResultService.getSqlServerCountBySerialNumber(job.getSerialNumber());
            if(n != 0 && !optionDialog("已有工單，是否重做？")) {
                return;
            }
            
            // 創建結果表
            TestResult t = new TestResult();

            // 寫入工單號
            String orderNum = job.getOrderNum();
            t.setOrderNum(orderNum);
            OPCUnit.write(opc.getItem_ordernum(), orderNum);

            // 寫入序列號
            String sn = job.getSerialNumber();
            t.setSerialNumber(sn);
            OPCUnit.write(opc.getItem_sn(), sn.split("[.]"));

            // 寫入箱體號
            String unitSize = job.getUnitSize();
            t.setUnitSize(unitSize);
            OPCUnit.write(opc.getItem_boxnum(), unitSize.split(" ")[0]);

            // 裝配機
            String assembly = LocalDataStore.read("localName");
            t.setAssembly(assembly);
            // 操作員
            User user = (User) AppContext.getParam(GlobalVariable.PARAM_KEY_USER);
            t.setOperator(user.getUserName());
            // 異常
            t.setAbnormal("是");

            // 保存結果表到全局變量
            AppContext.setParam(GlobalVariable.PARAM_KEY_TESTRESULT, t);

            // 寫入狀態字
            OPCUnit.write(opc.getItem_status(), "2");

            // 焦點返回掃碼框
            main.getScanCode().requestFocus();

            // 狀態信息
            setStatus(Color.GREEN, "發送成功，等待設備處理");
        }
    }

    /**
     * 設置主界面狀態信息
     */
    private void setStatus(Color color, String status) {
        main.getStatus().setText(status);
        main.getStatus().setBackground(color);
    }
    
    /**
     * @Title: optionDialog
     * @Description: 選擇彈窗，默認選擇：是
     */
    private boolean optionDialog(String message) {
        int i = PopupDialog.open(PopupManager.DEFAULT, "提醒窗口", message, new String[] { "是", "否" }, new int[] { 1, 2 },
                1, 2);
        if (i == 1) {
            return true;
        } else {
            return false;
        }
    }
}

10.地址變量

package cn.com.tcb.assembly.management.listener;

import java.io.IOException;
import java.util.Properties;

/**
 * @ClassName: OPCElement
 * @Description: PC和PLC通信使用的OPCserver上的標記名稱列表
 */
public class OPCElement {
	private final static Properties prop;
	private final static String CONFIG_FILE_NAME = "opc_list.properties";

	/**
	 * 加載配置文件
	 */
	static {
		prop = new Properties();
		try {
			prop.load(OPCElement.class.getClassLoader().getResourceAsStream(CONFIG_FILE_NAME));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 心跳： 讀到1，寫入2
	 */
	public static final String ITEMID_HEARTBEAT = prop.getProperty("addr01");

	/**
	 * 狀態控制字： 0：PLC上電，1：允許新工單，2：新任務，3：收到任務，4：准備執行，5：開始執行 6：正常完成，7：異常玩常完成，8：收到完成信號
	 */
	public static final String ITEMID_STATUS = prop.getProperty("addr02");

	/**
	 * 工單號：7位工單號，如：5332087
	 */
	public static final String ITEMID_ORDERNUM = prop.getProperty("addr03");

	/**
	 * 序列號，長整型，數組[6]
	 */
	public static final String ITEMID_SN = prop.getProperty("addr04");

	/**
	 * 箱體號：字符串，如：“R27”
	 */
	public static final String ITEMID_BOXNUM = prop.getProperty("addr12");

	/**
	 * 異常代碼：暫時沒用
	 */
	public static final String ITEMID_ABNORMAL = prop.getProperty("addr06");

	/**
	 * 完成信號：暫時沒用
	 */
	public static final String ITEMID_FINISH = prop.getProperty("addr07");

	/**
	 * 結果：浮點型，數組[20]
	 */
	public static final String ITEMID_RESULT = prop.getProperty("addr08");
	
	/**
	 * 裝配策略，內容：箱體號-軸s數量：字符串，如：“R107-2”
	 */
	public static final String ITEMID_STRATEGY = prop.getProperty("addr05");

	/**
	 * 工單號：7位工單號，如：5332087，，用來掃碼發送
	 */
	public static final String ITEMID_BARCODE = prop.getProperty("addr10");
	
	/**
	 * 墊片值：浮點型，數組[8]
	 */
	public static final String ITEMID_GASKET = prop.getProperty("addr11");
	
	/**
	 * 安裝方式：字符串，如：“M1”
	 */
	public static final String ITEMID_MP = prop.getProperty("addr09");
	
	/**
	 * 軸數量：字符串，如：“2”，“3”
	 */
	public static final String ITEMID_SHAFT = prop.getProperty("addr13");
}

地址寫在了配置文件里

opc_list.properties

#heartbeat:short
addr01=PLC.S7-300.TAG1
#control:short
addr02=PLC.S7-300.TAG2
#orderNum:long
addr03=PLC.S7-300.TAG3
#sn:long,array[6]
addr04=PLC.S7-300.TAG4
#Strategy:string
addr05=PLC.S7-300.TAG5
#abnormal:short
addr06=PLC.S7-300.TAG6
#finish:short
addr07=PLC.S7-300.TAG7
#result:float,array[20]
addr08=PLC.S7-300.TAG8
#MP:string
addr09=PLC.S7-300.TAG9
#barcode:long
addr10=PLC.S7-300.TAG10
#gasket:float,array[8]
addr11=PLC.S7-300.TAG11
#boxNum:string
addr12=PLC.S7-300.TAG12
#shaft:string
addr13=PLC.S7-300.TAG13

11.其他

另一個項目的，配置地址寫在了代碼里

OPCClient.java

package cn.com.tcb.uavpcs.datacenter.comm.plc.opcclient;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Executors;

import org.jinterop.dcom.common.JIException;
import org.openscada.opc.lib.common.ConnectionInformation;
import org.openscada.opc.lib.da.AccessBase;
import org.openscada.opc.lib.da.Group;
import org.openscada.opc.lib.da.Item;
import org.openscada.opc.lib.da.Server;
import org.openscada.opc.lib.da.SyncAccess;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import cn.com.tcb.uavpcs.datacenter.comm.plc.opcclient.callbacks.OvenCrossCallback;
import cn.com.tcb.uavpcs.datacenter.comm.plc.opcclient.callbacks.CrossCallbackFactory;
import cn.com.tcb.uavpcs.datacenter.comm.plc.opcclient.callbacks.OvenMoveCallBackFactory;
import cn.com.tcb.uavpcs.datacenter.comm.plc.opcclient.callbacks.StationCallBack;
import cn.com.tcb.uavpcs.datacenter.comm.plc.opcclient.items.OPCItems;
import cn.com.tcb.uavpcs.datacenter.linecontrol.LineModel;

/**
 * OPC客戶端，用於同PLC通信，通過OPC服務器，
 * 
 */
@Component
public class OPCClient {
	private static Logger logger = LoggerFactory.getLogger(OPCClient.class);

	public final static Map<String, Item> ITEMS = new HashMap<String, Item>();// 所有的變量對象
	@Autowired
	private OPCConfig config;

	private AccessBase access;

	public void start() throws Exception {
		logger.info("OPC客戶端初始化啟動");

		// 連接信息
		ConnectionInformation ci = new ConnectionInformation();
		ci.setHost(config.getHost());// 主機地址
		ci.setUser(config.getUser());// 用戶名
		ci.setPassword(config.getPassword());// 密碼
		ci.setClsid(config.getClsid());// clsId，使用DCOM組件的clsId連接OPC服務器
		// 連接服務器
		Server server = new Server(ci, Executors.newSingleThreadScheduledExecutor());
		server.connect();
		// 變量組
		Group group = server.addGroup();

		// 變量統一加入組，方便以后讀寫
		// 路口動作
		addItem(group, OPCItems.ITEM_CROSS_ACTION_1);
		addItem(group, OPCItems.ITEM_CROSS_ACTION_2);
		addItem(group, OPCItems.ITEM_CROSS_ACTION_3);
		addItem(group, OPCItems.ITEM_CROSS_ACTION_4);
		addItem(group, OPCItems.ITEM_CROSS_ACTION_5);
		addItem(group, OPCItems.ITEM_CROSS_ACTION_6);
		addItem(group, OPCItems.ITEM_CROSS_ACTION_7);
		addItem(group, OPCItems.ITEM_CROSS_ACTION_8);
		// 托盤進出gongwei
		addItem(group, OPCItems.ITEM_CROSS_FROM_1);
		addItem(group, OPCItems.ITEM_CROSS_FROM_2);
		addItem(group, OPCItems.ITEM_CROSS_FROM_3);
		addItem(group, OPCItems.ITEM_CROSS_FROM_4);
		addItem(group, OPCItems.ITEM_CROSS_FROM_5);
		addItem(group, OPCItems.ITEM_CROSS_FROM_6);
		addItem(group, OPCItems.ITEM_CROSS_FROM_7);
		addItem(group, OPCItems.ITEM_CROSS_FROM_8);
		// 線體1烘箱存取
		addItem(group, OPCItems.ITEM_OVEN_ACTION_1);
		addItem(group, OPCItems.ITEM_OVEN_COLUMN_1);
		addItem(group, OPCItems.ITEM_OVEN_LAYER_1);
		addItem(group, OPCItems.ITEM_OVEN_ROW_1);
		addItem(group, OPCItems.ITEM_OVEN_STATE_1);
		// 線體2烘箱存取
		addItem(group, OPCItems.ITEM_OVEN_ACTION_2);
		addItem(group, OPCItems.ITEM_OVEN_COLUMN_2);
		addItem(group, OPCItems.ITEM_OVEN_LAYER_2);
		addItem(group, OPCItems.ITEM_OVEN_ROW_2);
		addItem(group, OPCItems.ITEM_OVEN_STATE_2);

		access = new SyncAccess(server, 500);

		// 路口動作
		access.addItem(OPCItems.ITEM_CROSS_1, CrossCallbackFactory.build(LineModel.CROSS_ID_1));
		access.addItem(OPCItems.ITEM_CROSS_2, CrossCallbackFactory.build(LineModel.CROSS_ID_2));
		access.addItem(OPCItems.ITEM_CROSS_3, CrossCallbackFactory.build(LineModel.CROSS_ID_3));
		access.addItem(OPCItems.ITEM_CROSS_4, new OvenCrossCallback(LineModel.LINE_ID_1));// 烘箱路口，線體1

		access.addItem(OPCItems.ITEM_CROSS_5, CrossCallbackFactory.build(LineModel.CROSS_ID_5));
		access.addItem(OPCItems.ITEM_CROSS_6, CrossCallbackFactory.build(LineModel.CROSS_ID_6));
		access.addItem(OPCItems.ITEM_CROSS_7, CrossCallbackFactory.build(LineModel.CROSS_ID_7));
		access.addItem(OPCItems.ITEM_CROSS_8, new OvenCrossCallback(LineModel.LINE_ID_2));// 烘箱路口，線體2

		// 線體1，烘箱存取
		access.addItem(OPCItems.ITEM_OVEN_STATE_1, OvenMoveCallBackFactory.build(LineModel.LINE_ID_1));// 烘箱存取托盤，線體1

		// 線體2，烘箱存取
		access.addItem(OPCItems.ITEM_OVEN_STATE_2, OvenMoveCallBackFactory.build(LineModel.LINE_ID_2));// 烘箱存取托盤，線體2

		// 工位按鈕動作
		access.addItem(OPCItems.ITEM_STATION_1, new StationCallBack(LineModel.STATION_ID_1));
		access.addItem(OPCItems.ITEM_STATION_2, new StationCallBack(LineModel.STATION_ID_2));
		access.addItem(OPCItems.ITEM_STATION_3, new StationCallBack(LineModel.STATION_ID_3));
		access.addItem(OPCItems.ITEM_STATION_4, new StationCallBack(LineModel.STATION_ID_4));
		access.addItem(OPCItems.ITEM_STATION_5, new StationCallBack(LineModel.STATION_ID_5));
		access.addItem(OPCItems.ITEM_STATION_6, new StationCallBack(LineModel.STATION_ID_6));
		access.addItem(OPCItems.ITEM_STATION_7, new StationCallBack(LineModel.STATION_ID_7));
		access.addItem(OPCItems.ITEM_STATION_8, new StationCallBack(LineModel.STATION_ID_8));
		access.addItem(OPCItems.ITEM_STATION_9, new StationCallBack(LineModel.STATION_ID_9));
		access.addItem(OPCItems.ITEM_STATION_10, new StationCallBack(LineModel.STATION_ID_10));
		access.addItem(OPCItems.ITEM_STATION_11, new StationCallBack(LineModel.STATION_ID_11));
		access.addItem(OPCItems.ITEM_STATION_12, new StationCallBack(LineModel.STATION_ID_12));

		// 綁定，開始讀取
		access.bind();

		// Thread.sleep(100 * 1000);// 延時停止
		// access.unbind();// 結束綁定
		logger.info("OPC客戶端初始化啟動完成");
	}

	private void addItem(Group group, String itemId) throws Exception {
		Item item = group.addItem(itemId);
		ITEMS.put(itemId, item);
	}

	public void stop() {
		try {
			access.unbind();
		} catch (JIException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

OPCItems.java

package cn.com.tcb.uavpcs.datacenter.comm.plc.opcclient.items;

import java.util.HashMap;
import java.util.Map;

/**
 * 相關PLC變量在OPC服務器上的標簽
 *
 */
public class OPCItems {
	// 路口，狀態，對應8個路口，int
	public final static String ITEM_CROSS_1 = "u.u.cross1";
	public final static String ITEM_CROSS_2 = "u.u.cross2";
	public final static String ITEM_CROSS_3 = "u.u.cross3";
	public final static String ITEM_CROSS_4 = "u.u.cross4";
	public final static String ITEM_CROSS_5 = "u.u.cross5";
	public final static String ITEM_CROSS_6 = "u.u.cross6";
	public final static String ITEM_CROSS_7 = "u.u.cross7";
	public final static String ITEM_CROSS_8 = "u.u.cross8";
	// 路口，動作，對應8個路口，int
	public final static String ITEM_CROSS_FROM_1 = "u.u.from1";
	public final static String ITEM_CROSS_FROM_2 = "u.u.from2";
	public final static String ITEM_CROSS_FROM_3 = "u.u.from3";
	public final static String ITEM_CROSS_FROM_4 = "u.u.from4";
	public final static String ITEM_CROSS_FROM_5 = "u.u.from5";
	public final static String ITEM_CROSS_FROM_6 = "u.u.from6";
	public final static String ITEM_CROSS_FROM_7 = "u.u.from7";
	public final static String ITEM_CROSS_FROM_8 = "u.u.from8";
	// 路口，條碼，對應8個路口，String
	// public final static String ITEM_CROSS_BARCODE_1 = "u.u.barcode1";
	// public final static String ITEM_CROSS_BARCODE_2 = "u.u.barcode2";
	// public final static String ITEM_CROSS_BARCODE_3 = "u.u.barcode3";
	// public final static String ITEM_CROSS_BARCODE_4 = "u.u.barcode4";
	// public final static String ITEM_CROSS_BARCODE_5 = "u.u.barcode5";
	// public final static String ITEM_CROSS_BARCODE_6 = "u.u.barcode6";
	// public final static String ITEM_CROSS_BARCODE_7 = "u.u.barcode7";
	// public final static String ITEM_CROSS_BARCODE_8 = "u.u.barcode8";
	// 路口，動作，對應8個路口，int
	public final static String ITEM_CROSS_ACTION_1 = "u.u.action1";
	public final static String ITEM_CROSS_ACTION_2 = "u.u.action2";
	public final static String ITEM_CROSS_ACTION_3 = "u.u.action3";
	public final static String ITEM_CROSS_ACTION_4 = "u.u.action4";
	public final static String ITEM_CROSS_ACTION_5 = "u.u.action5";
	public final static String ITEM_CROSS_ACTION_6 = "u.u.action6";
	public final static String ITEM_CROSS_ACTION_7 = "u.u.action7";
	public final static String ITEM_CROSS_ACTION_8 = "u.u.action8";
	// 工位按鈕，12個工位
	public final static String ITEM_STATION_1 = "u.u.station1";
	public final static String ITEM_STATION_2 = "u.u.station2";
	public final static String ITEM_STATION_3 = "u.u.station3";
	public final static String ITEM_STATION_4 = "u.u.station4";
	public final static String ITEM_STATION_5 = "u.u.station5";
	public final static String ITEM_STATION_6 = "u.u.station6";
	public final static String ITEM_STATION_7 = "u.u.station7";
	public final static String ITEM_STATION_8 = "u.u.station8";
	public final static String ITEM_STATION_9 = "u.u.station9";
	public final static String ITEM_STATION_10 = "u.u.station10";
	public final static String ITEM_STATION_11 = "u.u.station11";
	public final static String ITEM_STATION_12 = "u.u.station12";
	// 線體1，烘箱存取控制
	public final static String ITEM_OVEN_STATE_1 = "u.u.oven1";
	public final static String ITEM_OVEN_ACTION_1 = "u.u.ovenaction1";
	public final static String ITEM_OVEN_COLUMN_1 = "u.u.column1";
	public final static String ITEM_OVEN_LAYER_1 = "u.u.layer1";
	public final static String ITEM_OVEN_ROW_1 = "u.u.row1";
	// 線體2，烘箱存取控制
	public final static String ITEM_OVEN_STATE_2 = "u.u.oven2";
	public final static String ITEM_OVEN_ACTION_2 = "u.u.ovenaction2";
	public final static String ITEM_OVEN_COLUMN_2 = "u.u.column2";
	public final static String ITEM_OVEN_LAYER_2 = "u.u.layer2";
	public final static String ITEM_OVEN_ROW_2 = "u.u.row2";

	// // 路口和條碼的對應關系
	// public final static Map<String, String> CROSS_BARCODES = new HashMap<String,
	// String>();
	// static {
	// CROSS_BARCODES.put(ITEM_CROSS_1, ITEM_CROSS_BARCODE_1);
	// CROSS_BARCODES.put(ITEM_CROSS_2, ITEM_CROSS_BARCODE_2);
	// CROSS_BARCODES.put(ITEM_CROSS_3, ITEM_CROSS_BARCODE_3);
	// CROSS_BARCODES.put(ITEM_CROSS_4, ITEM_CROSS_BARCODE_4);
	// CROSS_BARCODES.put(ITEM_CROSS_5, ITEM_CROSS_BARCODE_5);
	// CROSS_BARCODES.put(ITEM_CROSS_6, ITEM_CROSS_BARCODE_6);
	// CROSS_BARCODES.put(ITEM_CROSS_7, ITEM_CROSS_BARCODE_7);
	// CROSS_BARCODES.put(ITEM_CROSS_8, ITEM_CROSS_BARCODE_8);
	// }
	// // 路口和動作的對應關系
	// public final static Map<String, String> CROSS_ACTIONS = new HashMap<String,
	// String>();
	// static {
	// CROSS_BARCODES.put(ITEM_CROSS_1, ITEM_CROSS_ACTION_1);
	// CROSS_BARCODES.put(ITEM_CROSS_2, ITEM_CROSS_ACTION_2);
	// CROSS_BARCODES.put(ITEM_CROSS_3, ITEM_CROSS_ACTION_3);
	// CROSS_BARCODES.put(ITEM_CROSS_4, ITEM_CROSS_ACTION_4);
	// CROSS_BARCODES.put(ITEM_CROSS_5, ITEM_CROSS_ACTION_5);
	// CROSS_BARCODES.put(ITEM_CROSS_6, ITEM_CROSS_ACTION_6);
	// CROSS_BARCODES.put(ITEM_CROSS_7, ITEM_CROSS_ACTION_7);
	// CROSS_BARCODES.put(ITEM_CROSS_8, ITEM_CROSS_ACTION_8);
	// }
}

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 java連接OPC之——Windows7 With SP1 網絡OPC的DCOM配置 Kepware軟件基本操作及使用Java Utgard實現OPC通信 OPC UA 使用OPC與PLC通訊一 IGS OPC UA 配置 OPC UA 和 MQTT C# OPC使用 OPC的DCOM配置 OPC UA 的本質 OPC API 簡介