public void ReadValiesSynchronously()
{
Uri url = UrlBuilder.Build("Matrikon.OPC.Simulation.1");
using (var server = new OpcDaServer(url))
{
// Connect to the server first.
server.Connect();
// Create a group with items.
OpcDaGroup group = CreateGroupWithItems(server);
// Read values of items from device synchronously.
OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device);
// Output values
foreach (OpcDaItemValue value in values)
{
Console.WriteLine("ItemId: {0}; Value: {1}; Quality: {2}; Timestamp: {3}",
value.Item.ItemId, value.Value, value.Quality, value.Timestamp);
}
// The output should be like the following:
// ItemId: Bucket Brigade.Int4; Value: 0; Quality: Good+Good+NotLimited; Timestamp: 04/18/2016 13:40:57 +03:00
// ItemId: Random.Int2; Value: 26500; Quality: Good+Good+NotLimited; Timestamp: 04/18/2016 13:40:57 +03:00
values.Should().OnlyContain(v => v.Error.Succeeded);
values.Should().OnlyContain(v => v.Quality.Master == OpcDaQualityMaster.Good);
}
}
public void setItemsCount(string groupKey, OpcDaGroup group)
{
try
{
OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device);
if (values.Length == group.Items.Count)
{
for (int i = 0; i < values.Length; ++i)
{
if (values[i].Value != null)
{
if (itemscountCollection.ContainsKey(groupKey) == false)
{
itemscountCollection.Add(groupKey, 1);
itemstotalCollection.Add(groupKey, 1);
}
else
{
itemscountCollection[groupKey] = itemscountCollection[groupKey] + 1;
itemstotalCollection[groupKey] = itemstotalCollection[groupKey] + 1;
}
}
}
}
}
catch (Exception e)
{
LogHelper.Log("Exception: " + e.ToString());
}
}
static void Main()
{
Bootstrap.Initialize();
Uri url = UrlBuilder.Build("Matrikon.OPC.Simulation.1");
using (var server = new OpcDaServer(url))
{
// Connect to the server first.
server.Connect();
// Create a group with items.
OpcDaGroup group = server.AddGroup("MyGroup");
group.IsActive = true;
var definition1 = new OpcDaItemDefinition
{
ItemId = "Random.Boolean",
IsActive = true
};
var definition2 = new OpcDaItemDefinition
{
ItemId = "Random.Int1",
IsActive = true
};
var definition3 = new OpcDaItemDefinition
{
ItemId = "Random.Int2",
IsActive = true
};
OpcDaItemDefinition[] definitions = { definition1, definition2, definition3 };
OpcDaItemResult[] results = group.AddItems(definitions);
// Handle adding results.
foreach (OpcDaItemResult result in results)
{
if (result.Error.Failed)
{
Console.WriteLine("Error adding items: {0}", result.Error);
}
}
while (true)
{
OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device);
Console.WriteLine("Random.Boolean: {0} \n Random.Int1: {1} \n Random.Int2: {2}", values[0].Value, values[1].Value, values[2].Value);
Thread.Sleep(1000);
Console.Clear();
}
/*int count = server.Groups.Count;
* Console.WriteLine(count);*/
}
}
public static void AddOrUpdateEventGroup(string opcServerUrl, OpcEventGroup eventGroup)
{
lock (GetLockObject(opcServerUrl))
{
OpcDaServer server = GetServer(opcServerUrl);
if (server == null)
{
return;
}
if (eventGroup?.Paths == null || eventGroup.Paths.Length == 0)
{
RemoveEventGroup(opcServerUrl, eventGroup.EventId);
return;
}
// If server isn't connected or there is no ping thread running, then we aren't listening, and can't do anything here:
PingThread pingThread;
if (!ServerIsConnected(opcServerUrl) || !pingThreads.TryGetValue(opcServerUrl, out pingThread) || !pingThread.IsRunning)
{
return;
}
string groupName = "DecisionsGroup_" + eventGroup.EventId;
OpcDaGroup group = server.Groups.FirstOrDefault(x => x.Name == groupName);
if (group == null)
{
group = server.AddGroup(groupName);
group.IsActive = true;
AddItemIdsToGroup(group, eventGroup.Paths);
OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device);
Callback(opcServerUrl, eventGroup.EventId, ConvertToBaseTagValues(values)); // Send all current values in this group before subscribing to further changes
group.ValuesChanged += (object sender, OpcDaItemValuesChangedEventArgs e) =>
{
Callback(opcServerUrl, eventGroup.EventId, ConvertToBaseTagValues(e.Values));
};
}
else
{
string[] addedPaths = eventGroup.Paths.Except(group.Items.Select(x => x.ItemId)).ToArray();
OpcDaItem[] removedItems = group.Items.Where(x => !eventGroup.Paths.Contains(x.ItemId)).ToArray();
AddItemIdsToGroup(group, addedPaths);
if (removedItems.Length > 0)
{
group.RemoveItems(removedItems); // could check return value for errors here
}
}
group.PercentDeadband = eventGroup.Deadband;
group.UpdateRate = TimeSpan.FromMilliseconds(eventGroup.UpdateRate > 0 ? eventGroup.UpdateRate : 100); // ValuesChanged won't be triggered if zero
}
}
public static OpcInitialData GetInitialData(string opcServerUrl, bool valuesOnly)
{
lock (GetLockObject(opcServerUrl))
{
OpcDaServer server = GetOrCreateServer(opcServerUrl);
var browser = new OpcDaBrowserAuto(server);
OpcDaGroup group = server.AddGroup("DecisionsDataTypeGroup");
OpcNode[] nodes = GetNodesRecursive(browser, group, null);
//now that group has all tags, read all initial values at once:
OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device);
server.RemoveGroup(group);
return(new OpcInitialData {
Nodes = valuesOnly ? null : nodes, Values = ConvertToBaseTagValues(values)
});
}
}
public List <Item> ReadItemsValues(string host, string serverID, string groupKey)
{
OpcDaService server = GetOpcDaService(host, serverID);
if (server == null)
{
return(null);
}
if (server.OpcDaGroupS.ContainsKey(groupKey) == true)
{
OpcDaGroup group = server.OpcDaGroupS[groupKey];
OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device);
if (values.Length != group.Items.Count)
{
LogHelper.Log($"values.Length(${values.Length}) != group.Items.Count(${group.Items.Count}) ");
return(null);
}
List <Item> itemValues = new List <Item>();
for (int i = 0; i < values.Length; ++i)
{
Item it = new Item();
it.ItemId = group.Items[i].ItemId;
it.Data = values[i].Value;
if (values[i].Value != null)
{
it.Data = values[i].Value;
it.Type = values[i].Value.GetType().ToString();
itemValues.Add(it);
}
}
return(itemValues);
}
return(null);
}
public void read_group(string opcserver, string group_name, List <string> items)
{
Uri url = UrlBuilder.Build(opcserver);
using (var server = new OpcDaServer(url))
{
// Connect to the server first.
server.Connect();
// Create a group with items.
OpcDaGroup group = server.AddGroup(group_name);
IList <OpcDaItemDefinition> definitions = new List <OpcDaItemDefinition>();
int i = 0;
foreach (string id in items)
{
LogHelper.Log("id: " + id);
var definition = new OpcDaItemDefinition
{
ItemId = id,
IsActive = true
};
definitions.Insert(i++, definition);
}
group.IsActive = true;
OpcDaItemResult[] results = group.AddItems(definitions);
OpcDaItemValue[] itemValues = group.Read(group.Items, OpcDaDataSource.Device);
// Handle adding results.
JsonObject data = new JsonObject();
foreach (OpcDaItemValue item in itemValues)
{
if (item.Item != null && item.Value != null)
{
data.Add(item.Item.ItemId, item.Value);
}
}
server.Disconnect();
}
}
public async Task WriteValiesToAnItemOfAnOpcServerAsynchronously()
{
Uri url = UrlBuilder.Build("Matrikon.OPC.Simulation.1");
using (var server = new OpcDaServer(url))
{
// Connect to the server first.
server.Connect();
// Create a group with items.
OpcDaGroup group = CreateGroupWithItems(server);
// Write value to the item.
OpcDaItem item = group.Items.FirstOrDefault(i => i.ItemId == "Bucket Brigade.Int4");
OpcDaItem[] items = { item };
object[] values = { 123 };
HRESULT[] results = await group.WriteAsync(items, values);
// Handle write result.
if (results[0].Failed)
{
Console.WriteLine("Error writing value");
}
// Read and output value.
OpcDaItemValue value = group.Read(items, OpcDaDataSource.Device)[0];
Console.WriteLine("ItemId: {0}; Value: {1}; Quality: {2}; Timestamp: {3}",
value.Item.ItemId, value.Value, value.Quality, value.Timestamp);
// The output should be like the following:
// ItemId: Bucket Brigade.Int4; Value: 123; Quality: Good+Good+NotLimited; Timestamp: 04/18/2016 14:04:11 +03:00
value.Value.Should().Be(123);
value.Quality.Master.Should().Be(OpcDaQualityMaster.Good);
}
}
public JsonObject GetUnits(OpcDaGroup group)
{
JsonObject units = new JsonObject();
try
{
OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device);
if (values.Length == group.Items.Count)
{
for (int i = 0; i < values.Length; ++i)
{
if (values[i].Value != null)
{
units.Add(values[i].Item.ItemId, values[i].Value.GetType().ToString());
}
}
}
}
catch (Exception)
{
}
return(units);
}
public OpcDaItemValue[] readTag(bool _sync = false, Action <OpcDaItemValue[]> _callBack = null)
{
//da excecao caso o argumento callback seja nulo com o comando assyncrono
if ((_sync == false) && (_callBack == null))
{
throw(new ArgumentNullException());
}
// Create a group with items.
readingGroup.SyncItems();
Console.Write("reading group -> ");
Console.WriteLine(readingGroup);
Console.WriteLine("lendo");
//faz leitura das tags
if (_sync)
{
// Read all items of the group synchronously.
var values = readingGroup.Read(readingGroup.Items, OpcDaDataSource.Device);
foreach (var val in values)
{
Console.Write(val.Item.ItemId);
Console.Write(" -- \t");
Console.Write(val.Value);
Console.Write(" -- \t\t\t\t");
Console.Write((int)val.Quality);
Console.Write(" -- \t\t");
Console.Write(val.Timestamp);
Console.Write(" -- \t\t");
Console.WriteLine((int)val.Error);
}
}
else
{
void completed(Task <OpcDaItemValue[]> values)
{/*
* //OpcDaItemValue[] values = group.ReadAsync(group.Items);
* foreach(OpcDaItemValue val in values.Result)
* {
* Console.Write(val.Item.ItemId);
* Console.Write(" -- \t");
* Console.Write(val.Value);
* Console.Write(" -- \t\t\t\t");
* Console.Write((int) val.Quality);
* Console.Write(" -- \t\t");
* Console.Write(val.Timestamp);
* Console.Write(" -- \t\t");
* Console.WriteLine((int) val.Error);
* }
*/
//chama o callback definido na funcao
_callBack((OpcDaItemValue[])values.Result);
}
var readingTask = readingGroup.ReadAsync(readingGroup.Items, this.readingCancelationToken);
Action <Task <OpcDaItemValue[]> > receiverData = completed;
readingTask.ContinueWith(receiverData);
// Read all items of the group asynchronously.
//OpcDaItemValue[] values = group.ReadAsync(group.Items);
//foreach(var val in values)
//{
// Console.WriteLine(val);
//}
}
return(null);
}
private void OpcConnect()
{
try
{
Uri url = UrlBuilder.Build("CoDeSys.OPC.DA");
using (var server = new OpcDaServer(url))
{
server.Connect();
OpcDaGroup group = server.AddGroup("MyGroup");
group.IsActive = true;
var definition1 = new OpcDaItemDefinition
{
ItemId = "PLC_GW3.Application.GVL.ROLL_X",
IsActive = true
};
var definition2 = new OpcDaItemDefinition
{
ItemId = "PLC_GW3.Application.GVL.PITCH_Y",
IsActive = true
};
var definition3 = new OpcDaItemDefinition
{
ItemId = "PLC_GW3.Application.GVL.YAW_Z",
IsActive = true
};
OpcDaItemDefinition[] definitions = { definition1, definition2, definition3 };
OpcDaItemResult[] results = group.AddItems(definitions);
foreach (OpcDaItemResult result in results)
{
if (result.Error.Failed)
{
throw new Exception("Definicje nie weszły");
}
}
while (_continue)
{
try
{
OpcDaItemValue[] values = group.Read(group.Items, OpcDaDataSource.Device);
Dispatcher.Invoke((Action)(() =>
{
dataCont.x = Convert.ToInt32(values[0].Value) / 10;
dataCont.y = Convert.ToInt32(values[1].Value) / 10;
dataCont.z = Convert.ToInt32(values[2].Value) / 10;
ChartUpdate((double)dataCont.x, (double)dataCont.y, (double)dataCont.z);
}));
Thread.Sleep(80);
}
catch (NotSupportedException en)
{
_continue = false;
MessageBox.Show(en.Message + "\n" + en.StackTrace + "\n" + en.Source);
}
}
server.Disconnect();
}
}
catch (Exception en)
{
MessageBox.Show(en.Message);
}
}
private async void Time_Elapsed(object sender, ElapsedEventArgs e)
{
try
{
//await Task.Run(() =>
//{
var Values = groupLeap130.Read(groupLeap130.Items, OpcDaDataSource.Device);
UpdateOpcLEAP130?.Invoke(Values, null);
_errOpcLEAP130 = false;
//}
//);
}
catch
{
if (!_errOpcLEAP130)
{
Console.WriteLine(DateTime.Now + " : Error from OPC read LEAP130");
errOpcLEAP130?.Invoke();
// LogWriter.WriteLog("", "", "Error from OPC read LEAP130", 0);
_errOpcLEAP130 = true;
}
}
try
{
var Values = groupLeap300.Read(groupLeap300.Items, OpcDaDataSource.Device);
UpdateOpcLEAP300?.Invoke(Values, null);
_errOpcLEAP300 = false;
}
catch
{
if (!_errOpcLEAP300)
{
Console.WriteLine(DateTime.Now + " : Error from OPC read LEAP300");
errOpcLEAP300?.Invoke();
// LogWriter.WriteLog("", "", "Error from OPC read LEAP300", 0);
_errOpcLEAP300 = true;
}
}
try
{
var Values1 = groupPldA.Read(groupPldA.Items, OpcDaDataSource.Device);
UpdateOpcPldA?.Invoke(Values1, null);
_errOpcPldA = false;
}
catch
{
if (!_errOpcPldA)
{
Console.WriteLine(DateTime.Now + " : Error from OPC read PLD-A");
errOpcPldA?.Invoke();
// LogWriter.WriteLog("", "", "Error from OPC read PLD-A", 0);
_errOpcPldA = true;
}
}
try
{
var Values = groupPldB.Read(groupPldB.Items, OpcDaDataSource.Device);
UpdateOpcPldB?.Invoke(Values, null);
_errOpcPldB = false;
}
catch
{
if (!_errOpcPldB)
{
Console.WriteLine(DateTime.Now + " : Error from OPC read PLD-B");
errOpcPldB?.Invoke();
// LogWriter.WriteLog("", "", "Error from OPC read PLD-B", 0);
_errOpcPldB = true;
}
}
try
{
var Values = groupSilver.Read(groupSilver.Items, OpcDaDataSource.Device);
//Console.WriteLine("Done");
UpdateOpcSilver?.Invoke(Values, null);
_errOpcSilver = false;
}
catch
{
if (!_errOpcSilver)
{
Console.WriteLine(DateTime.Now + " : Error from OPC read PLD-A");
errOpcSilver?.Invoke();
// LogWriter.WriteLog("", "", "Error from OPC read PLD-A", 0);
_errOpcSilver = true;
}
}
}
private async void Time_Elapsed(object sender, ElapsedEventArgs e)
{
await Task.Run(() =>
{
try
{
var Values = groupIBAD.Read(groupIBAD.Items, OpcDaDataSource.Device);
UpdateOpcIBAD?.Invoke(Values, null);
errorWriteIBAD = false;
}
catch
{
if (!errorWriteIBAD)
{
Console.WriteLine(DateTime.Now + " Error from OPC read PLC");
ErrorOpcIBAD?.Invoke();
LogWriter.WriteLog("", "", "Error from OPC read IBAD", 0);
errorWriteIBAD = true;
}
}
try
{
var Values1 = groupMOIKA.Read(groupMOIKA.Items, OpcDaDataSource.Device);
UpdateOpcMOIKA?.Invoke(Values1, null);
errorWriteMOIKA = false;
}
catch
{
if (!errorWriteMOIKA)
{
Console.WriteLine(DateTime.Now + " Error from OPC read MOIKA");
ErrorOpcMOIKA?.Invoke();
LogWriter.WriteLog("", "", "Error from OPC read MOIKA", 0);
errorWriteMOIKA = true;
}
}
try
{
var Values2 = groupSCADA.Read(groupSCADA.Items, OpcDaDataSource.Device);
UpdateOpcSCADA?.Invoke(Values2, null);
errorWriteSCADA = false;
}
catch
{
if (!errorWriteSCADA)
{
Console.WriteLine(DateTime.Now + " Error from OPC read SCADA");
ErrorOpcSCADA?.Invoke();
LogWriter.WriteLog("", "", "Error from OPC read SCADA", 0);
errorWriteSCADA = true;
}
}
try
{
var Values3 = groupTERM.Read(groupTERM.Items, OpcDaDataSource.Device);
UpdateOpcTERM?.Invoke(Values3, null);
errorWriteTERM = false;
}
catch
{
if (!errorWriteTERM)
{
Console.WriteLine(DateTime.Now + " Error from OPC read TERM");
ErrorOpcTERM?.Invoke();
LogWriter.WriteLog("", "", "Error from OPC read TERM", 0);
errorWriteTERM = true;
}
}
});
GC.Collect();
}
