public int GetNodeValue(string nodeStrGuid, out object nodeValue)
{
int rtc = -1;
nodeValue = null;
try
{
OPCDATASOURCE opcDataSource = OPCDATASOURCE.OPC_DS_DEVICE;
OPCItemState opcItemState = new OPCItemState();
DriveNodeEntity driveNode = allOPCItemNodes.Find(p => nodeStrGuid.Equals(p.nodeId));
ItemDef itemdef = syncIOGroup.Item(driveNode.nodeName);
rtc = syncIOGroup.Read(opcDataSource, itemdef, out opcItemState);
if (HRESULTS.Succeeded(rtc))
{
nodeValue = opcItemState.DataValue;
//txtItemQuality.Text = syncIOGroup.GetQualityString(opcItemState.Quality);
//txtTimeStamp.Text = DateTime.FromFileTime(opcItemState.TimeStamp).ToString();
}
}
catch (Exception ex)
{
NLogHelper.ExceptionInfo(ex, "GetNodeValue param:'{1}' ,exception:{0}", ex.Message, nodeStrGuid);
}
return(rtc);
}
public bool SyncRead(GroupName enumGrp, ItemName[] enumArryItem, out bool[] arrResult)
{
bool bResult;
string strGrp = enumGrp.ToString();
var grp = opcResultsDic[strGrp];
arrResult = new bool[enumArryItem.Length];
int[] arrHandle = new int[enumArryItem.Length];
for (int i = 0; i < enumArryItem.Length; i++)
{
string strItem = enumArryItem[i].ToString();
arrHandle[i] = grp[strItem].HandleServer;
}
OPCItemState[] arrState = new OPCItemState[enumArryItem.Length];
try
{
bResult = opcGrpsDic[strGrp].SyncRead(OPCDATASOURCE.OPC_DS_DEVICE, arrHandle, out arrState);
}
catch (Exception)
{
bResult = false;
}
for (int i = 0; i < arrState.Length; i++)
{
arrResult[i] = (bool)arrState[i].DataValue;
}
return(bResult);
}
public string WriteStringItem(String tagName, String value)
{
ItemDef ItemData = new ItemDef();
ItemData = readGroup.Item(tagName);
OPCItemState state = new OPCItemState();
int rtc = readGroup.Write(ItemData, value);
if (HRESULTS.Succeeded(rtc)) // read from OPC server successful
{
if (state != null)
{
if (HRESULTS.Succeeded(state.Error)) // item read successful
{
return("Success");
}
else // the item could not be read
{
// hf.LogException("Item cannot be readable: " + tagName);
return("ERROR");
}
}
else // State not valid
{
// hf.LogException("Item cannot be readable due to state: " + tagName);
return("ERROR");
}
}
else // OPC server read error
{
// hf.LogException("Item cannot be readable due to OPC: " + tagName);
return("ERROR");
}
}
public void readSyn(int[] arryHandleServer, int length, out String[] arryResult)
{
OPCItemState[] arrystate = new OPCItemState[length];
arryResult = new String[length];
try
{
if (arryHandleServer != null)
{
TheGrp.SyncRead(OPCDATASOURCE.OPC_DS_DEVICE, arryHandleServer, out arrystate);
}
if (arrystate != null)
{
for (int i = 0; i < arrystate.Length; i++)
{
if (arrystate[i].Quality == 192)
{
arryResult[i] = arrystate[i].DataValue.ToString();
}
else
{
arryResult[i] = arrystate[i].Quality.ToString();
}
}
}
}
catch (Exception e)
{
System.Windows.Forms.MessageBox.Show(e.ToString());
}
}
static void group_ReadCompleted(object sender, ReadCompleteEventArgs e)
{
Console.WriteLine("Async read:");
for (int i = 0; i < e.sts.Length; i++)
{
OPCItemState itemResult = e.sts[i];
Console.WriteLine(" -> item:{0}; value:{1}; timestamp{2}; qualituy:{3}", "n/a", itemResult.DataValue.ToString(), itemResult.TimeStamp, itemResult.Quality);
}
;
}
public void TestOPCItemStateString01()
{
OPCItemState itemState = new OPCItemState();
itemState.Error = 0;
itemState.HandleClient = 1;
itemState.DataValue = 1;
itemState.TimeStamp = System.DateTime.Now.ToFileTime();
itemState.Quality = 8;
//Test Procedure Call
string result = itemState.ToString();
}
void pushValue(OPCItemState itemState, Action <int, PointValueType, object> onValueReceive)
{
int itemTranId = itemState.HandleClient;
if (itemState.DataValue == null)
{
onValueReceive(itemTranId, PointValueType.String, "");
}
else if (itemState.DataValue is Array)
{
onValueReceive(itemTranId, PointValueType.String, Newtonsoft.Json.JsonConvert.SerializeObject(itemState.DataValue));
}
else
{
onValueReceive(itemTranId, PointValueType.String, itemState.DataValue.ToString());
}
}
/// <summary>
/// This function reads a analog double tag value from OPC, read will be from Device, Return ERROR in case of any error
/// </summary>
/// <param name="tagName"></param>
/// <returns></returns>
public int ReadBooleanItem(String tagName)
{
ItemDef ItemData;
ItemData = readGroup.Item(tagName);
OPCItemState state = new OPCItemState();
// Read from device
OPCDATASOURCE dsrc = OPCDATASOURCE.OPC_DS_DEVICE;
int rtc = readGroup.Read(dsrc, ItemData, out state);
if (HRESULTS.Succeeded(rtc)) // read from OPC server successful
{
if (state != null)
{
if (HRESULTS.Succeeded(state.Error)) // item read successful
{
if (Convert.ToBoolean(state.DataValue) == true)
{
return(1);
}
else
{
return(0);
}
}
else // the item could not be read
{
// hf.LogException("Item cannot be readable: " + tagName);
return(-10000);
}
}
else // State not valid
{
// hf.LogException("Item cannot be readable due to State: " + tagName);
return(-10000);
}
}
else // OPC server read error
{
// hf.LogException("Item cannot be readable due to OPC: " + tagName);
return(-10000);
}
}
public bool SyncRead(GroupName enumGrp, ItemName enumItem, out bool iResult)
{
bool bExec;
string strGrp = enumGrp.ToString();
int[] arrHandle = new int[] { opcResultsDic[strGrp][enumItem.ToString()].HandleServer };
OPCItemState[] arrState = new OPCItemState[1];
try
{
bExec = opcGrpsDic[strGrp].SyncRead(OPCDATASOURCE.OPC_DS_DEVICE, arrHandle, out arrState);
}
catch (Exception ee)
{
bExec = false;
LogImpl.Debug("plc错误:" + ee.ToString());
}
iResult = (bool)arrState[0].DataValue;
return(bExec);
}
private void cmdReadSync_Click(object sender, EventArgs e)
{
int[] aE = new int[2];
_txtReadVal_0.Text = "";
_txtReadVal_1.Text = "";
int[] arrHSrv = new int[2];
OPCItemState[] arrStat = new OPCItemState[2];
arrHSrv[0] = itemResults[0].HandleServer;
arrHSrv[1] = itemResults[1].HandleServer;
try
{
theGroup.SyncRead(OPCDATASOURCE.OPC_DS_DEVICE, arrHSrv, out arrStat);
if (arrStat[0].Quality == 192)
{
_txtReadVal_0.Text = arrStat[0].DataValue.ToString();
_txtReadVal_0.BackColor = Color.White;
}
else
{
_txtReadVal_0.Text = GetQualityText(arrStat[0].Quality);
_txtReadVal_0.BackColor = Color.Red;
}
if (arrStat[1].Quality == 192)
{
_txtReadVal_1.Text = arrStat[1].DataValue.ToString();
_txtReadVal_1.BackColor = Color.White;
}
else
{
_txtReadVal_1.Text = GetQualityText(arrStat[1].Quality);
_txtReadVal_1.BackColor = Color.Red;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private string AddMyRefreshGroup1(OpcServer OpcSrv)
{
float deadBand = 90.0F;
try
{ // create group with 2 sec update rate
oGrp = OpcSrv.AddGroup("Line1", true, UpdateRate, ref deadBand, 0, 0);
}
catch
{
DBLogging.InsertLogs("Exception: AddMyRefreshGroup1", false, "Group could not be added", _connStr);
return("Group could not be added");
}
oGrp.DataChanged += new DataChangeEventHandler(DataChangedHandler);
oGrp.AdviseIOPCDataCallback();
//client handle as item index
items1[0] = new OPCItemDef(TagLPG_Bay01_RFID_Puched, true, 0, VarEnum.VT_BOOL);
items1[1] = new OPCItemDef(TagLPG_WB_RFIDPunched, true, 1, VarEnum.VT_BOOL);
items1[2] = new OPCItemDef(TagLPG_Bay01_LPGBatchComplete, true, 2, VarEnum.VT_BOOL);
int rtc;
rtc = oGrp.AddItems(items1, out addRslt1);
if (HRESULTS.Failed(rtc))
{
return("Error at AddItem");
}
for (int i = 0; i < addRslt1.Length; ++i)
{
ItemValues1[i] = new OPCItemState();
}
return("");
}
/// <summary>
/// This function reads a tag value from OPC, read will be from Device, Return ERROR in case of any error
/// </summary>
/// <param name="tagName"></param>
/// <returns></returns>
public string ReadStringItem(String tagName)
{
ItemDef ItemData = new ItemDef();
ItemData = readGroup.Item(tagName);
OPCItemState state = new OPCItemState();
// Read from device
OPCDATASOURCE dsrc = OPCDATASOURCE.OPC_DS_CACHE; //??????????
int rtc = readGroup.Read(dsrc, ItemData, out state);
if (HRESULTS.Succeeded(rtc)) // read from OPC server successful
{
if (state != null)
{
if (HRESULTS.Succeeded(state.Error)) // item read successful
{
return(state.DataValue.ToString());
}
else // the item could not be read
{
// hf.LogException("Item cannot be readable: " + tagName);
return("ERROR");
}
}
else // State not valid
{
// hf.LogException("Item cannot be readable due to state: " + tagName);
return("ERROR");
}
}
else // OPC server read error
{
// hf.LogException("Item cannot be readable due to OPC: " + tagName);
return("ERROR");
}
}
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();
}
public void TestCreateOPCItemState01()
{
OPCItemState oPCItemState = CreateOPCItemState01();
Assert.IsNotNull(oPCItemState);
}
public static OPCItemState CreateOPCItemState01()
{
OPCItemState oPCItemState = new OPCItemState();
return(oPCItemState);
}
