// connect to OPC server via ProgID
public bool DoConnect(string progid)
{
try
{
theSrv.Connect(progid);
Thread.Sleep(100);
theSrv.SetClientName("DirectOPC " + thisprocess.Id); // set my client name (exe+process no)
SERVERSTATUS sts;
theSrv.GetStatus(out sts);
// get infos about OPC server
StringBuilder sb = new StringBuilder(sts.szVendorInfo, 200);
sb.AppendFormat(" ver:{0}.{1}.{2}", sts.wMajorVersion, sts.wMinorVersion, sts.wBuildNumber);
//txtServerInfo.Text = sb.ToString();
// set status bar text to show server state
//sbpTimeStart.Text = DateTime.FromFileTime(sts.ftStartTime).ToString();
//sbpStatus.Text = sts.eServerState.ToString();
}
catch (COMException)
{
//MessageBox.Show(this, "connect error!", "Exception", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return(false);
}
return(true);
}
static void Main(string[] args)
{
string progID = args.Length > 0 ? args[0] : "Kepware.KEPServerEX.V5";
OpcServer opcServer = new OpcServer();
opcServer.Connect(progID);
System.Threading.Thread.Sleep(500); // we are faster than some servers!
SERVERSTATUS serverStatus = opcServer.GetStatus();
Console.WriteLine("'{0}' vendor '{1}' version {2}.{3}.{4}",
progID,
serverStatus.szVendorInfo,
serverStatus.wMajorVersion, serverStatus.wMinorVersion, serverStatus.wBuildNumber);
Console.WriteLine("State : {0}", serverStatus.eServerState);
Console.WriteLine("Start time : {0}", DateTime.FromFileTime(serverStatus.ftStartTime));
Console.WriteLine("Last update : {0}", DateTime.FromFileTime(serverStatus.ftLastUpdateTime));
Console.WriteLine("Current time: {0}", DateTime.FromFileTime(serverStatus.ftCurrentTime));
// Bandwith and group count valid only for this connection
Console.WriteLine("Bandwidth : {0}", serverStatus.dwBandWidth);
Console.WriteLine("Group count : {0}", serverStatus.dwGroupCount);
opcServer.GetLocaleID(out int lcid);
Console.WriteLine("Locale ID: {0}", lcid);
opcServer.Disconnect();
}
private OpcServerConnectResult DoConnect(string progid)
{
OpcServerConnectResult result = new OpcServerConnectResult {
IsSuccess = false
};
try
{
_theSrv.Connect(progid);
Thread.Sleep(100);
_theSrv.SetClientName("DirectOPC " + Process.GetCurrentProcess().Id); // set my client name (exe+process no)
SERVERSTATUS sts;
_theSrv.GetStatus(out sts);
// get infos about OPC server
StringBuilder sb = new StringBuilder(sts.szVendorInfo, 200);
sb.AppendFormat(" ver:{0}.{1}.{2}", sts.wMajorVersion, sts.wMinorVersion, sts.wBuildNumber);
result.ServerInfo = sb.ToString();
// set status to show server state
result.SbpTimeStart = DateTime.FromFileTime(sts.ftStartTime);
result.SbpStatus = sts.eServerState.ToString();
result.IsSuccess = true;
return(result);
}
catch (COMException ex)
{
result.ErrorText = ex.Message;
return(result);
}
}
public void TestGetStatus01()
{
//testing --
OpcServer opcServer = new OpcServer();
Accessor opcServerAccessor = ReflectionAccessor.Wrap(opcServer);
opcServerAccessor.SetField("ifServer", new OPCServerComClass());
SERVERSTATUS serverStatus;
//Test Procedure Call
opcServer.GetStatus(out serverStatus);
//Post Condition Check
}
// public OpcServer opcServer { get; set; }
public static bool IsOpcServerConnectionAvailable()
{
if (opcServer == null)
{
opcServer = new OpcServer();
}
int rtc = 0;
SERVERSTATUS objSERVERSTATUS = new SERVERSTATUS();
bool isConnected = false;
bool isServerRunning = true;
try
{
isConnected = opcServer.isConnectedDA;
if (isConnected)
{
opcServer.GetStatus(out objSERVERSTATUS);
isServerRunning = objSERVERSTATUS.eServerState == OpcServerState.Running;
}
if (!isConnected || !isServerRunning)
{
opcMachineHost = GlobalValues.OPC_MACHINE_HOST;
opcServerName = GlobalValues.OPC_SERVER_NAME;
rtc = opcServer.Connect(opcMachineHost, opcServerName);
}
}
catch (Exception errMsg)
{
Console.WriteLine("" + errMsg);
}
finally { }
return(opcServer.isConnectedDA);
}
/// <summary>
/// Returns whether Server is connected or not.
/// </summary>
/// <returns></returns>
public bool IsOPCServerConnected()
{
string Function_Name = "IsOPCServerConnected";
LogHelper.Trace(CLASS_NAME, Function_Name, "Function_Entered");
bool ret = false;
lock (m_opcDataDicObj)
{
if (m_opcSrvConnectFlag)
{
SERVERSTATUS sts = new SERVERSTATUS();
sts.eServerState = OPCSERVERSTATE.OPC_STATUS_RUNNING;
try
{
m_OPCServer.GetStatus(out sts);
if (sts.eServerState != OPCSERVERSTATE.OPC_STATUS_RUNNING)
{
LogHelper.Info(CLASS_NAME, Function_Name, string.Format("status is {0}", sts.eServerState.ToString()));
}
//bool statusFlag = (sts.eServerState == OPCSERVERSTATE.OPC_STATUS_RUNNING) ? true : false;
}
catch (Exception localException)
{
LogHelper.Error(CLASS_NAME, Function_Name, localException);
//check is server is ok?
//if (localException.Message.Contains("The RPC server is unavailable."))
// Fixed issue - related to System Language, to avoid it used Error code
if (localException.Message.Contains("0x800706BA"))
{
m_opcSrvConnectFlag = false;
}
}
}
ret = m_opcSrvConnectFlag;
}
if (!ret)
{
LogHelper.Debug(CLASS_NAME, Function_Name, "OPC Server status is Down!");
}
LogHelper.Trace(CLASS_NAME, Function_Name, "Function_Exited");
return(ret);
}
public static bool GetOPCServerStatus(OpcServer opcSer, out int opcSerStatus)
{
bool theGetServerStatusSucceed = false;
opcSerStatus = -1;
SERVERSTATUS theServerStatus;
try
{
opcSerStatus = opcSer.GetStatus(out theServerStatus);
if (HRESULTS.Succeeded(opcSerStatus))
{
theGetServerStatusSucceed = true;
}
}
catch (Exception err)
{
NLogHelper.ExceptionInfo(err, "GetOPCServerStatus error :{0}", err.Message);
}
return(theGetServerStatusSucceed);
}
static void Main(string[] args)
{
/*create array of readable Tags*/
var Tags = new List <OPCClientItem>();
Tags.Add(new OPCClientItem()
{
Name = ".test",
ClientHanle = 1
});
OpcServer server = new OpcServer();
try
{
int transactionID = new Random().Next(1024, 65535);
int cancelID = 0;
int updateRate = 1000;
/*connect to the OPC Server and check it's state*/
server.Connect("Matrikon.OPC.Simulation.1");
var serverStatus = new SERVERSTATUS();
server.GetStatus(out serverStatus);
if (serverStatus.eServerState == OPCSERVERSTATE.OPC_STATUS_RUNNING)
{
/*create group of items*/
OpcGroup group = server.AddGroup("Group1", true, updateRate);
group.ReadCompleted += group_ReadCompleted;
List <OPCItemDef> items = new List <OPCItemDef>();
Tags.ToList()
.ForEach(x => items.Add(new OPCItemDef(x.Name, true, x.ClientHanle, VarEnum.VT_EMPTY)));
/* add items and collect their attributes*/
OPCItemResult[] itemAddResults = null;
group.AddItems(items.ToArray(), out itemAddResults);
for (int i = 0; i < itemAddResults.Length; i++)
{
OPCItemResult itemResult = itemAddResults[i];
OPCClientItem tag = Tags[i];
tag.ServerHandle = itemResult.HandleServer;
tag.AccessRight = (itemResult.AccessRights == OPCACCESSRIGHTS.OPC_READABLE) ? OPCClientItem.EAccessRight.ReadOnly : OPCClientItem.EAccessRight.ReadAndWrite;
}
;
/*Refresh items in group*/
// group.Refresh2(OPCDATASOURCE.OPC_DS_DEVICE, transactionID, out cancelID);
/*Async read data for the group items*/
int[] serverHandles = new int[Tags.Count];
for (int i = 0; i < Tags.Count; i++)
{
serverHandles[i] = Tags[i].ServerHandle;
}
;
OPCItemState[] itemsStateResult = null;
/*sync read*/
group.Read(OPCDATASOURCE.OPC_DS_DEVICE, serverHandles, out itemsStateResult);
Console.WriteLine("Sync read:");
for (int i = 0; i < itemsStateResult.Length; i++)
{
OPCItemState itemResult = itemsStateResult[i];
Console.WriteLine(" -> item:{0}; value:{1}; timestamp{2}; qualituy:{3}", Tags[i].Name, itemResult.DataValue.ToString(), itemResult.TimeStamp, itemResult.Quality);
}
;
/*sync write*/
object[] values = new object[Tags.Count];
int[] resultErrors = new int[Tags.Count];
values[0] = (object)256;
group.Write(serverHandles, values, out resultErrors);
/*async read*/
group.Read(serverHandles, transactionID, out cancelID, out resultErrors);
/*wait for a while befor remove group to process async event*/
System.Threading.Thread.Sleep(3000);
/*the group must be removed !!! */
group.Remove(true);
}
;
}
finally
{
server.Disconnect();
server = null;
GC.Collect();
};
Console.ReadKey();
}
/// <summary>
/// initialize OPC server and group
/// </summary>
/// <param name="serverName">OPC Server Name</param>
/// <param name="groupName">OPC Group name under the OPC server.
/// Here groupName is trendViewer Process ID in string</param>
///
public void InitializeServer(string serverName, string groupName)
{
string Function_Name = "InitializeServer";
LogHelper.Trace(CLASS_NAME, Function_Name, "Function_Entered");
lock (m_opcDataDicObj)
{
try
{
m_OPCSrvName = serverName;
m_OPCGroupName = groupName;
//Fix - Remove opcGroup and Disconnect server to avoid GC Fianlizer thread call these methods
try
{
if (m_OPCGroup != null)
{
m_OPCGroup.Remove(false);
m_OPCGroup = null;
}
if (m_OPCServer != null)
{
m_OPCServer.Disconnect();
m_OPCServer = null;
}
}
catch (Exception localException)
{
LogHelper.Error(CLASS_NAME, Function_Name, localException);
}
m_OPCServer = new OpcServer();
LogHelper.Trace(CLASS_NAME, Function_Name, "Before Connect");
m_OPCServer.Connect(serverName);
LogHelper.Trace(CLASS_NAME, Function_Name, "After Connect");
Thread.Sleep(200);
m_OPCServer.SetClientName("DirectOPC " + groupName + serverName); // set my client name (exe+process no)
SERVERSTATUS sts;
m_OPCServer.GetStatus(out sts);
LogHelper.Info(CLASS_NAME, Function_Name, serverName + ": " + DateTime.FromFileTime(sts.ftStartTime).ToString());
LogHelper.Info(CLASS_NAME, Function_Name, serverName + ": " + sts.eServerState.ToString());
// add event handler for server shutdown
m_OPCServer.ShutdownRequested += new ShutdownRequestEventHandler(this.OPCSrv_ServerShutDown);
//Setup opc group
m_OPCGroup = m_OPCServer.AddGroup("MFTOPC-Group-" + serverName, true, UPDATEGROUPRATE);
m_OPCGroup.DataChanged += new DataChangeEventHandler(this.OPCGrp_DataChange);
m_opcSrvConnectFlag = true;
}
catch (COMException localException)
{
LogHelper.Error(CLASS_NAME, Function_Name, localException);
LogHelper.Info(CLASS_NAME, Function_Name, "Initialize of the OPC Server is not successful");
}
catch (Exception localException)
{
LogHelper.Error(CLASS_NAME, Function_Name, localException);
}
}
LogHelper.Trace(CLASS_NAME, Function_Name, "Function_Exited");
}
/// <summary>
/// This is our layout update routine, that keeps refreshing the screen on each cycle of our thread monitor
/// </summary>
/// <param name="_curStatus"></param>
private void UpdateStatus(eOPCMonitoringStatus _curStatus)
{
int cResult;
OpcServer theOPCServer = new OpcServer();
try
{
OPCDA.SERVERSTATUS curOPCSrvStatus;
cResult = theOPCServer.Connect(theOPCServerTopic);
if (theKeepAliveMonitorIsEnabled)
{
tbKeepAliveConfigStatus.BackColor = Color.DarkGreen;
tbKeepAliveConfigStatus.ForeColor = Color.White;
tbKeepAliveConfigStatus.Text = "Enabled";
}
else
{
tbKeepAliveConfigStatus.BackColor = Color.LightGray;
tbKeepAliveConfigStatus.ForeColor = Color.DarkGray;
tbKeepAliveConfigStatus.Text = "Disabled";
}
if (theSchedulerIsEnabled)
{
tbSchedulerConfigStatus.BackColor = Color.DarkGreen;
tbSchedulerConfigStatus.ForeColor = Color.White;
tbSchedulerConfigStatus.Text = "Enabled";
tbSchedulerTimeConfigured.Text = theSchedulerTime.TimeOfDay.ToString();
}
else
{
tbSchedulerConfigStatus.BackColor = Color.LightGray;
tbSchedulerConfigStatus.ForeColor = Color.DarkGray;
tbSchedulerConfigStatus.Text = "Disabled";
tbSchedulerTimeConfigured.Text = "";
}
switch (cResult)
{
case HRESULTS.E_FAIL:
theOPCMonitorStatus = eOPCMonitoringStatus.Failed;
break;
case HRESULTS.OPC_E_NOTFOUND:
theOPCMonitorStatus = eOPCMonitoringStatus.Failed;
break;
case HRESULTS.CONNECT_E_ADVISELIMIT:
theOPCMonitorStatus = eOPCMonitoringStatus.Expired;
break;
case HRESULTS.CONNECT_E_NOCONNECTION:
theOPCMonitorStatus = eOPCMonitoringStatus.NoConnection;
break;
case HRESULTS.S_OK:
theOPCMonitorStatus = eOPCMonitoringStatus.Connected;
break;
case HRESULTS.S_FALSE:
theOPCMonitorStatus = eOPCMonitoringStatus.Failed;
break;
default:
theOPCMonitorStatus = eOPCMonitoringStatus.Undefined;
theOPCServerDiagnostic = "";
break;
}
switch (theOPCMonitorStatus)
{
case eOPCMonitoringStatus.Inactive:
tbOpcSrvMonitoringStatus.BackColor = Color.LightGray;
tbOpcSrvMonitoringStatus.ForeColor = Color.DarkGray;
break;
case eOPCMonitoringStatus.Undefined:
tbOpcSrvMonitoringStatus.BackColor = Color.LightGray;
tbOpcSrvMonitoringStatus.ForeColor = Color.DarkGray;
break;
case eOPCMonitoringStatus.Connecting:
tbOpcSrvMonitoringStatus.BackColor = Color.LightGreen;
tbOpcSrvMonitoringStatus.ForeColor = Color.Black;
break;
case eOPCMonitoringStatus.Connected:
tbOpcSrvMonitoringStatus.BackColor = Color.DarkGreen;
tbOpcSrvMonitoringStatus.ForeColor = Color.White;
break;
case eOPCMonitoringStatus.Expired:
tbOpcSrvMonitoringStatus.BackColor = Color.Yellow;
tbOpcSrvMonitoringStatus.ForeColor = Color.Black;
break;
case eOPCMonitoringStatus.Disconnected:
tbOpcSrvMonitoringStatus.BackColor = Color.LightCoral;
tbOpcSrvMonitoringStatus.ForeColor = Color.Black;
break;
case eOPCMonitoringStatus.Failed:
tbOpcSrvMonitoringStatus.BackColor = Color.Red;
tbOpcSrvMonitoringStatus.ForeColor = Color.White;
break;
case eOPCMonitoringStatus.Restarting:
tbOpcSrvMonitoringStatus.BackColor = Color.LightBlue;
tbOpcSrvMonitoringStatus.ForeColor = Color.Black;
break;
default:
tbOpcSrvMonitoringStatus.BackColor = Color.LightGray;
tbOpcSrvMonitoringStatus.ForeColor = Color.Black;
break;
}
if (theSchedulerIsEnabled == true &&
DateTime.Now.TimeOfDay >= theSchedulerTime.TimeOfDay &&
DateTime.Now.Day > theLastRestartTime.Day)
{
while (OPCServerProcessIsRunning())
{
KillWindowsProcess();
Thread.Sleep(1000);
}
theLastRestartTime = DateTime.Now;
}
if (theOPCServer != null && theOPCServer.isConnectedDA)
{
theOPCServer.GetStatus(out curOPCSrvStatus);
if (curOPCSrvStatus.eServerState.ToString() == "0")
{
theOPCServerDiagnostic = "License Expired";
}
else
{
theOPCServerDiagnostic = curOPCSrvStatus.eServerState.ToString();
}
switch (curOPCSrvStatus.eServerState)
{
case OPCDA.OpcServerState.Failed:
tbOpcSrvDiagnostic.BackColor = Color.Red;
tbOpcSrvDiagnostic.ForeColor = Color.White;
if (theKeepAliveMonitorIsEnabled)
{
while (OPCServerProcessIsRunning())
{
KillWindowsProcess();
Thread.Sleep(1000);
}
}
break;
case OPCDA.OpcServerState.Suspended:
tbOpcSrvDiagnostic.BackColor = Color.Yellow;
tbOpcSrvDiagnostic.ForeColor = Color.Black;
if (theKeepAliveMonitorIsEnabled)
{
while (OPCServerProcessIsRunning())
{
KillWindowsProcess();
Thread.Sleep(1000);
}
}
break;
case OPCDA.OpcServerState.NoConfig:
tbOpcSrvDiagnostic.BackColor = Color.White;
tbOpcSrvDiagnostic.ForeColor = Color.Black;
break;
case OPCDA.OpcServerState.Running:
tbOpcSrvDiagnostic.BackColor = Color.DarkGreen;
tbOpcSrvDiagnostic.ForeColor = Color.White;
break;
case OPCDA.OpcServerState.Test:
tbOpcSrvDiagnostic.BackColor = Color.LightBlue;
tbOpcSrvDiagnostic.ForeColor = Color.Black;
break;
default:
tbOpcSrvDiagnostic.BackColor = Color.Yellow;
tbOpcSrvDiagnostic.ForeColor = Color.Black;
if (theKeepAliveMonitorIsEnabled)
{
while (OPCServerProcessIsRunning())
{
KillWindowsProcess();
Thread.Sleep(1000);
}
}
break;
}
}
else
{
tbOpcSrvDiagnostic.BackColor = Color.Gainsboro;
tbOpcSrvDiagnostic.ForeColor = Color.DarkGray;
}
}
catch
{
theOPCMonitorStatus = eOPCMonitoringStatus.Exception;
theOPCServerDiagnostic = "";
tbOpcSrvMonitoringStatus.BackColor = Color.Red;
tbOpcSrvMonitoringStatus.ForeColor = Color.White;
}
finally
{
tbOpcSrvMonitoringStatus.Text = theOPCMonitorStatus.ToString();
tbOpcSrvDiagnostic.Text = theOPCServerDiagnostic;
}
}
//[MethodImplAttribute(MethodImplOptions.Synchronized)]//Синхронизировать метод
private bool Connect()
{
lock (lockConn)
{
DateTime dt1 = DateTime.Now;
try
{
bool result;
//создадим соединение с БД
SERVERSTATUS status;
_opcsrv.GetStatus(out status);
if (_cntconn == 0 || status == null || status.eServerState != OPCSERVERSTATE.OPC_STATUS_RUNNING)
{
_opcsrv.Connect(_progid, _host);
_opcsrv.GetStatus(out status);
if (status != null && status.eServerState == OPCSERVERSTATE.OPC_STATUS_RUNNING)
{
try
{
_opcgrp = _opcsrv.AddGroup(_grpname, false, _interval);
_opcgrp.HandleClient = 0;
int _cnt = _maps.GetLength(0);
_serverhandles = new int[_cnt];
_vals = new object[_cnt];
_errs = new object[_cnt];
OPCItemDef[] _opcitmsdef = new OPCItemDef[_cnt];
for (int i = 0; i < _cnt; i++)
{
_opcitmsdef[i] = new OPCItemDef(_maps[i, 1], true, i, VarEnum.VT_EMPTY);
}
_opcgrp.AddItems(_opcitmsdef, out _opcitms);
for (int i = 0; i < _cnt; i++)
{
_serverhandles[i] = _opcitms[i].HandleServer;
}
_opcgrp.SetEnable(true);
_opcgrp.Active = true;
_server.LogWrite(LogType.DEBUG, "[" + this._name + "] : T(сек)=" + (DateTime.Now - dt1).Seconds + ", нап. груп. - " + _maps.GetLength(0));
_cntconn++; //Увеличим счётчик активных соединений
_server.LogWrite(LogType.DEBUG, "[" + this._name + "] : Connect - Активных соединений: " + _cntconn);
result = true;
}
catch (Exception e)
{
_server.LogWrite(LogType.ERROR, e.Message);
result = false;
}
}
else
{
result = false;
}
}
else
{
_cntconn++; //Увеличим счётчик активных соединений
result = true;
}
return(result);
}
finally
{
_server.LogWrite(LogType.DEBUG, "[" + this._name + "] : T(сек)=" + (DateTime.Now - dt1).Seconds + ", время на откытие соединения");
}
}
}
