public void piSystemPicker1_ConnectionChange(object sender, OSIsoft.AF.UI.SelectionChangeEventArgs e) { //Set the AF Server to the current selected object myAFServer = (PISystem)e.SelectedObject; AFDatabases databaseList = myAFServer.Databases; }
public AFProbe(string name, PISystem piSystem) { _name = name; _piSystem = piSystem; _startServer = piSystem.GetRpcMetrics(); _startClient = piSystem.GetClientRpcMetrics(); _sw = Stopwatch.StartNew(); }
static void PrintEnergyUOMs(PISystem system) { Console.WriteLine("Print Energy UOMs"); UOMClass uomClass = system.UOMDatabase.UOMClasses["Energy"]; foreach (UOM uom in uomClass.UOMs) { Console.WriteLine("UOM: {0}, Abbreviation: {1}", uom.Name, uom.Abbreviation); } Console.WriteLine(); }
static AFDatabase GetDatabase(string serverName, string databaseName) { PISystem assetServer = GetPISystem(null, serverName); if (!string.IsNullOrEmpty(databaseName)) { return(assetServer.Databases[databaseName]); } else { return(assetServer.Databases.DefaultDatabase); } }
static AFDatabase GetDatabase(string servername, string databasename) { PISystem system = GetPISystem(null, servername); if (!string.IsNullOrEmpty(databasename)) { return(system.Databases[databasename]); } else { return(system.Databases.DefaultDatabase); } }
public MainWindow() { PISystems piSystems = new PISystems(); aPiSystem = piSystems.DefaultPISystem; InitializeComponent(); Closed += MainWindow_Closed; InitializeComponent(); msalAuthHelper = new MsalAuthHelper(); RefreshSignInStatus(); }
static void Main(string[] args) { Options arguments = Parser.Default.ParseArguments<Options>(args).MapResult(options => options, _ => null); Logger logger = new Logger(true, arguments.LogFile != null ? arguments.LogFile : null); logger.Log("Started"); // Server logger.Log($"Connecting to server {arguments.ServerName}"); PIServer piServer = PIUtil.GetPIServer(arguments.ServerName); logger.Log($"Connecting to system {arguments.SystemName}"); PISystem piSystem = AFUtil.GetPISystem(arguments.SystemName); logger.Log("Connected"); logger.Log($"Listing databases: system {arguments.SystemName}"); AFUtil.WriteDatabases(piSystem, arguments.DatabaseOutputFile); // Database if (arguments.DatabaseName != null) { AFDatabase database = AFUtil.GetDatabase(piSystem, arguments.DatabaseName); logger.Log($"Listing attributes for database {database.Name}"); AFUtil.WriteAttributes(database, arguments.AttributeOutputFile); } else { var outputFileExtension = Path.GetExtension(arguments.AttributeOutputFile); var outputFileName = Path.ChangeExtension(arguments.AttributeOutputFile, null); AFDatabases databases = piSystem.Databases; Parallel.ForEach( databases, new ParallelOptions { MaxDegreeOfParallelism = arguments.NumParallelTasks }, (AFDatabase database) => { logger.Log($"Listing attributes: database {database.Name}"); AFUtil.WriteAttributes(database, $"{outputFileName} {database.Name}{outputFileExtension}"); }); } logger.Log("Finished - press Enter to close terminal"); logger.Close(); Console.ReadLine(); }
static AFDatabase GetDatabase(string serverName, string databaseName) { Console.WriteLine("Retrieving the AF database"); PISystem assetServer = GetPISystem(null, serverName); if (!string.IsNullOrEmpty(databaseName)) { return(assetServer.Databases[databaseName]); } else { return(assetServer.Databases.DefaultDatabase); } }
/// <summary> /// Initialize an AF Connnection object. /// it is required to call the Connect method before getting Database or the connected PISystem object /// </summary> /// <param name="server">Name of the PI System (AF Server) to connect to</param> /// <param name="databaseName">Name of the AF DatabaseName to connect to</param> public AFConnectionHelper(string server, string databaseName=null) { PISystems.DirectoryOptions = PISystems.AFDirectoryOptions.AutoAdd; if (_piSystems.Contains(server)) _piSystem = _piSystems[server]; else { _logger.Warn("PI System does not exist in the KST, it will be added"); _piSystem = _piSystems[server]; } _databaseName = databaseName; }
static AFDatabase GetDatabase(string servername, string databasename) { PISystems piafsystems = new PISystems(); PISystem system = piafsystems[servername]; if (system != null && system.Databases.Contains(databasename)) { Console.WriteLine("Found '{0}' with '{1}' databases", system.Name, system.Databases.Count); return(system.Databases[databasename]); } else { return(null); } }
public void ConnectToAfDatabase(string afServer, string afDatabase) { XmlConfigurator.Configure(); PISystems myPISystems = new PISystems(); PISystem myPISystem = string.IsNullOrEmpty(afServer) ? myPISystems.DefaultPISystem : myPISystems[afServer]; myPISystem.Connect(); Log.InfoFormat("SDK: {0}, Server: {1}", myPISystems.Version, myPISystem.ServerVersion); _afDatabase = string.IsNullOrEmpty(afDatabase) ? myPISystem.Databases.DefaultDatabase : myPISystem.Databases[afDatabase]; Log.InfoFormat("PI System {0} ; Database {1}", myPISystem.Name, _afDatabase.Name); }
private void piSystemPicker_SelectionChange(object sender, SelectionChangeEventArgs e) { PISystem pisystem = piSystemPicker.PISystem; if (pisystem != null) { AFElement limitcalculator = piSystemPicker.PISystem.Databases["Configuration"].Elements["LimitCalculator"]; if (limitcalculator == null) { piSystemPicker.PISystem.Databases["Configuration"].Elements.Add(new AFElement("LimitCalculator")); piSystemPicker.PISystem.Databases["Configuration"].CheckIn(); } configurationTreeView.AFRoot = piSystemPicker.PISystem.Databases["Configuration"].Elements["LimitCalculator"]; } }
public void Connect(string piSystemName, string afDatabaseName, string piDataArchiveName) { piPointNamesToBeCreated = new List <string>(); try { piSystem = new PISystems()[piSystemName]; piSystem.Connect(); log.Info("Connected to the AF Server."); } catch (Exception ex) { log.Fatal("Could not connect to AF Server: " + ex.Message); throw ex; } try { afDb = piSystem.Databases[afDatabaseName]; if (afDb == null) { log.Info("AF Database not found. Creating new AF Database."); afDb = piSystem.Databases.Add(afDatabaseName); } else { log.Info("AF Database found."); } } catch (Exception ex) { log.Fatal("Could not connect to AF Database: " + ex.Message); throw ex; } try { piServer = new PIServers()[piDataArchiveName]; piServer.Connect(); log.Info("Connected to the PI Data Archive."); } catch (Exception ex) { log.Fatal("Could not connect to PI Data Archive: " + ex.Message); throw ex; } }
public void Run() { PISystems piSystems = new PISystems(); PISystem piSystem = piSystems["<AFSERVER>"]; AFDatabase afDatabase = piSystem.Databases["NuGreen"]; const int pageSize = 1000; int startIndex = 0; int totalCount; do { // Find a collection of elements instantiated from the Boiler tempplate. // Only the Elements' header information (Name, Description, Template, Type, etc.) // are loaded from the AF Server by this call. AFNamedCollection <AFElement> elements = AFElement.FindElements( database: afDatabase, searchRoot: null, query: "Boiler", field: AFSearchField.Template, searchFullHierarchy: true, sortField: AFSortField.Name, sortOrder: AFSortOrder.Ascending, startIndex: startIndex, maxCount: pageSize, totalCount: out totalCount); if (elements == null) { break; } // This call goes to the AF Server to fully load the found elements in one call, // so further AF Server calls can be avoided. AFElement.LoadElements(elements); // Now we can use the elements without having to make any additional server calls. // In the example below, accessing the Attributes collection would have // caused an additional call per element if we had not called LoadElements previously. Console.WriteLine("Found {0} Elements.", elements.Count); foreach (AFElement item in elements) { Console.WriteLine(" Element {0} has {1} Attributes", item.Name, item.Attributes.Count); } startIndex += pageSize; } while (startIndex < totalCount); }
public PBToolkitBar() { InitializeComponent(); PISystems systems = new PISystems(); m_System = systems.DefaultPISystem; if (m_Database == null) { DialogResult dialogResult; m_Database = AFOperations.ConnectToDatabase(this, m_System.Name, "", true, out dialogResult); } m_FoundElement = null; btnConnect_Click(null, null); }
static UOMClass createUOM(PISystem system, string UOMClassName, string UOMCanonicalName, string UOMCanonicalAbbreviation) { UOMDatabase uomdb = system.UOMDatabase; UOMClass UOMClass = uomdb.UOMClasses[UOMClassName]; if (UOMClass == null) { UOMClass = uomdb.UOMClasses.Add(UOMClassName, UOMCanonicalName, UOMCanonicalAbbreviation); system.CheckIn(); } if (UOMClass.CanonicalUOM.Name != UOMCanonicalName) { throw new System.ArgumentException("The current existing UOM Classes has a different canonical UOM"); } return(UOMClass); }
/// <summary> /// Initialize an AF Connnection object. /// it is required to call the Connect method before getting Database or the connected PISystem object /// </summary> /// <param name="server">Name of the PI System (AF Server) to connect to</param> /// <param name="databaseName">Name of the AF DatabaseName to connect to</param> public AFConnectionHelper(string server, string databaseName = null) { PISystems.DirectoryOptions = PISystems.AFDirectoryOptions.AutoAdd; if (_piSystems.Contains(server)) { _piSystem = _piSystems[server]; } else { _logger.Warn("PI System does not exist in the KST, it will be added"); _piSystem = _piSystems[server]; } _databaseName = databaseName; }
public static void PrintEnergyUOMs(PISystem system) { if (system == null) { throw new ArgumentNullException(nameof(system)); } Console.WriteLine("Print Energy UOMs"); UOMClass uomClass = system.UOMDatabase.UOMClasses["Energy"]; foreach (UOM uom in uomClass.UOMs) { Console.WriteLine("UOM: {0}, Abbreviation: {1}", uom.Name, uom.Abbreviation); } Console.WriteLine(); }
static void Main(string[] args) { var options = new Options(); if (CommandLine.Parser.Default.ParseArguments(args, options)) { // Command values are available here uomgrouping = options.uomgrouping; } system = new PISystems().DefaultPISystem; var db = system.Databases.DefaultDatabase; UOMdb = system.UOMDatabase; dt = db.Tables["UOM Groupings"].Table; convertAttributesAndAnalysis(db); }
/// <summary> /// Initialize an AF Connnection object. /// it is required to call the Connect method before getting Database or the connected PISystem object /// </summary> /// <param name="server">Name of the PI System (AF Server) to connect to</param> /// <param name="databaseName">Name of the AF DatabaseName to connect to</param> public AfConnectionMgr(string server, string databaseName=null) { if (_piSystems.Contains(server)) _piSystem = _piSystems[server]; else { // in case you would like to force the auto-creation of the PI System in KST if it does not exist, uncomment the following two lines // and remove the exception throwing // // PISystems.DirectoryOptions = PISystems.AFDirectoryOptions.AutoAdd; // _piSystem = _piSystems[server]; throw new KeyNotFoundException("Specified PI System does not exist"); } _databaseName = databaseName; }
/// <summary> /// Removes the named notification contact template if it exists. /// </summary> /// <param name="name">The name of the notification contact template to remove.</param> /// <param name="output">The output logger used for writing messages.</param> public void RemoveNotificationContactTemplateIfExists(string name, ITestOutputHelper output) { Contract.Requires(output != null); var preCheckNCT = PISystem.NotificationContactTemplates[name]; if (preCheckNCT != null) { output.WriteLine($"Notification Contact Template [{preCheckNCT}] exists, delete it."); PISystem.NotificationContactTemplates.Remove(preCheckNCT); PISystem.CheckIn(); } else { output.WriteLine($"Notification Contact Template [{name}] does not exist, can not be deleted."); } }
/// <summary> /// Removes the UOM Class from the AF Database if it exists. /// </summary> /// <param name="name">The name of UOM Class to remove.</param> /// <param name="output">The output logger used for writing messages.</param> public void RemoveUOMClassIfExists(string name, ITestOutputHelper output) { Contract.Requires(output != null); var preCheckUOMClass = PISystem.UOMDatabase.UOMClasses[name]; if (preCheckUOMClass != null) { output.WriteLine($"UOM Class [{preCheckUOMClass}] exists, delete it."); PISystem.UOMDatabase.UOMClasses.Remove(preCheckUOMClass); PISystem.CheckIn(); } else { output.WriteLine($"UOM Class [{name}] does not exist, can not be deleted."); } }
static void Main(string[] args) { var options = new Options(); if (CommandLine.Parser.Default.ParseArguments(args, options)) { // Command values are available here currency = options.currency; rate = options.rate; } system = new PISystems().DefaultPISystem; var db = system.Databases.DefaultDatabase; UOMdb = system.UOMDatabase; dt = db.Tables["Currency Conversion"].Table; convertAttributesAndAnalysis(db); }
/// <summary> /// Example that shows how to connect to PI System /// in your application, you should keep a reference to piSystems so its not garbage collected. /// The class <see cref="AfConnectionHelper"/> illustrates this. (ctrl+click to navigate to the class.) /// </summary> /// <param name="server"></param> /// <returns></returns> public PISystem Connect(string server) { string serverName = server; PISystems piSystems = new PISystems(); // in case you would like to force the auto-creation of the PI System in KST if it does not exist, uncomment the following line // see: https://techsupport.osisoft.com/Documentation/PI-AF-SDK/html/T_OSIsoft_AF_PISystems_AFDirectoryOptions.htm // PISystems.DirectoryOptions = PISystems.AFDirectoryOptions.AutoAdd; PISystem piSystem = piSystems[serverName]; // true, null option will force a password dialog to appear. // you should not use this option for a service or an executable that runs outside a windows session. // instead use the empty constructor and make sure that the user that runs the application have an account that allows it to connect. piSystem.Connect(true, null); return(piSystem); }
public void Run() { PISystems piSystems = new PISystems(); PISystem piSystem = piSystems["<AFSERVER>"]; AFDatabase afDatabase = piSystem.Databases["NuGreen"]; AFCategory elementCategory = afDatabase.ElementCategories["Equipment Assets"]; AFCategory attributeCategory = afDatabase.AttributeCategories["Real-Time Data"]; AFElementTemplate elementTemplate = afDatabase.ElementTemplates["Boiler"]; const int pageSize = 1000; int startIndex = 0; int totalCount; do { // Find all "Water Flow" attributes in the NuGreen database. AFAttributeList attrList = AFAttribute.FindElementAttributes( database: afDatabase, searchRoot: null, nameFilter: "*", elemCategory: elementCategory, elemTemplate: elementTemplate, elemType: AFElementType.Any, attrNameFilter: "*", attrCategory: attributeCategory, attrType: TypeCode.Double, searchFullHierarchy: true, sortField: AFSortField.Name, sortOrder: AFSortOrder.Ascending, startIndex: startIndex, maxCount: pageSize, totalCount: out totalCount); foreach (AFAttribute attr in attrList) { Console.WriteLine("Parent element name: {0}", attr.Element); } startIndex += pageSize; } while (startIndex < totalCount); }
public void Run() { PISystems piSystems = new PISystems(); PISystem piSystem = piSystems["<AFSERVER>"]; AFDatabase afDatabase = piSystem.Databases["NuGreen"]; AFElement nuGreen = afDatabase.Elements["NuGreen"]; AFElement houston = nuGreen.Elements["Houston"]; AFElement crackingProcess = houston.Elements["Cracking Process"]; AFElement equipment = crackingProcess.Elements["Equipment"]; AFElement b210 = equipment.Elements["B-210"]; AFAttribute processFeedRate = b210.Attributes["Process Feedrate"]; AFValue val = processFeedRate.GetValue(); Console.WriteLine("Timestamp: {0}, Value: {1}", val.Timestamp, val.Value.ToString()); }
/// <summary> /// Initialize an AF Connnection object. /// it is required to call the Connect method before getting Database or the connected PISystem object /// </summary> /// <param name="server">Name of the PI System (AF Server) to connect to</param> /// <param name="databaseName">Name of the AF DatabaseName to connect to</param> public AfConnectionMgr(string server, string databaseName = null) { if (_piSystems.Contains(server)) { _piSystem = _piSystems[server]; } else { // in case you would like to force the auto-creation of the PI System in KST if it does not exist, uncomment the following two lines // and remove the exception throwing // // PISystems.DirectoryOptions = PISystems.AFDirectoryOptions.AutoAdd; // _piSystem = _piSystems[server]; throw new KeyNotFoundException("Specified PI System does not exist"); } _databaseName = databaseName; }
public void Run() { PISystems piSystems = new PISystems(); PISystem piSystem = piSystems["<AFSERVER>"]; AFDatabase afDatabase = piSystem.Databases["NuGreen"]; const int pageSize = 1000; int startIndex = 0; int totalCount; do { // Find a collection of elements instantiated from the Boiler tempplate. // Only the Elements' header information (Name, Description, Template, Type, etc.) // are loaded from the AF Server by this call. AFNamedCollection <AFElement> elements = AFElement.FindElements( database: afDatabase, searchRoot: null, query: "Boiler", field: AFSearchField.Template, searchFullHierarchy: true, sortField: AFSortField.Name, sortOrder: AFSortOrder.Ascending, startIndex: startIndex, maxCount: pageSize, totalCount: out totalCount); if (elements == null) { break; } // Because we are just retrieving the element's name, no additional calls // to the AF Server are made. Console.WriteLine("Found {0} Elements.", elements.Count); foreach (AFElement item in elements) { Console.WriteLine(" Element name is {0}.", item.Name); } startIndex += pageSize; } while (startIndex < totalCount); }
static void Main(string[] args) { myPISystem = new PISystems()["MARC-PI2014"]; PIServerName = "MARC-PI2014"; AFDatabase myDb = myPISystem.Databases["PIWebAPIWhitePaperSampleDb"]; if (myDb == null) { myDb = myPISystem.Databases.Add("PIWebAPIWhitePaperSampleDb"); } AFElementTemplate myCityTemplate = myDb.ElementTemplates["CityTemplate"]; if (myCityTemplate == null) { myCityTemplate = myDb.ElementTemplates.Add("Cities"); } UOM degreeC = myPISystem.UOMDatabase.UOMClasses["Temperature"].UOMs["degree Celsius"]; UOM speedKmph = myPISystem.UOMDatabase.UOMClasses["Speed"].UOMs["kilometer per hour"]; UOM millibar = myPISystem.UOMDatabase.UOMClasses["Pressure"].UOMs["milibar"]; UOM percent = myPISystem.UOMDatabase.UOMClasses["Ratio"].UOMs["percent"]; UOM kilometres = myPISystem.UOMDatabase.UOMClasses["Length"].UOMs["kilometer"]; CreateAttributeTemplate("Cloud Cover", myCityTemplate, typeof(int), percent); CreateAttributeTemplate("Humidity", myCityTemplate, typeof(double), percent); CreateAttributeTemplate("Pressure", myCityTemplate, typeof(int), millibar); CreateAttributeTemplate("Temperature", myCityTemplate, typeof(int), degreeC); CreateAttributeTemplate("Visibility", myCityTemplate, typeof(int), kilometres); CreateAttributeTemplate("Wind Speed", myCityTemplate, typeof(int), speedKmph); AFElement cities = myDb.Elements.Add("Cities"); cities.Elements.Add("Chicago", myCityTemplate); cities.Elements.Add("Los Angeles", myCityTemplate); cities.Elements.Add("New York", myCityTemplate); cities.Elements.Add("San Francisco", myCityTemplate); cities.Elements.Add("Washington", myCityTemplate); myDb.CheckIn(); }
public QLPiSystemResolve(PISystem aPiSystem, Field afDbsField) { name = aPiSystem.Name; if (afDbsField != null) { var nameFilterStrings = GraphQlHelpers.GetArgumentStrings(afDbsField, "nameFilter"); var afElementsField = GraphQlHelpers.GetFieldFromFieldOrContext(afDbsField, "afElements"); var returnElementsObject = new ConcurrentBag <QLAfDatabase>(); var afDbsList = aPiSystem.Databases; Parallel.ForEach(afDbsList, aAfDb => { if (nameFilterStrings.Count == 0 || nameFilterStrings.Contains(aAfDb.Name)) { returnElementsObject.Add(new QLAfDatabaseResolve(aAfDb, afElementsField)); } }); afDbs = returnElementsObject.OrderBy(x => x.name).ToList(); } }
private static AFDatabase CreateDatabase(string servername, string databasename) { AFDatabase database = null; PISystems piafsystems = new PISystems(); PISystem system = piafsystems[servername]; if (system != null) { if (system.Databases.Contains(databasename)) { database = system.Databases[databasename]; } else { database = system.Databases.Add(databasename); } } return(database); }
/// <summary> /// Creates an instance of the AFFixture class. /// </summary> public AFFixture() { var systems = new PISystems(); if (systems.Contains(Settings.AFServer)) { PISystem = systems[Settings.AFServer]; PISystem.Connect(); } else { throw new InvalidOperationException( $"The specific AF Server [{Settings.AFServer}] does not exist or is not configured."); } if (PISystem.Databases.Contains(Settings.AFDatabase)) { AFDatabase = PISystem.Databases[Settings.AFDatabase]; } }
public void Run() { PISystems piSystems = new PISystems(); PISystem piSystem = piSystems["<AFSERVER>"]; AFDatabase afDatabase = piSystem.Databases["Basic-AFSDK-Sample"]; AFElement boilerA = afDatabase.Elements["Region_0"].Elements["BoilerA"]; AFElementTemplate elementTemplate = afDatabase.ElementTemplates["BasicBoilerTemplate"]; AFAttributeTemplate temperatureAttrTemplate = elementTemplate.AttributeTemplates["Temperature"]; AFAttributeTemplate modeAttrTemplate = elementTemplate.AttributeTemplates["Mode"]; AFElement.LoadAttributes(new[] { boilerA }, new[] { temperatureAttrTemplate, modeAttrTemplate }); AFEnumerationSet digSet = afDatabase.EnumerationSets["Modes"]; IList <AFValue> valuesToWrite = new List <AFValue>(); for (int i = 0; i < 10; i++) { AFTime time = new AFTime(new DateTime(2015, 1, 1, i, 0, 0, DateTimeKind.Local)); AFValue afValueFloat = new AFValue(i, time); // Associate the AFValue to an attribute so we know where to write to. afValueFloat.Attribute = boilerA.Attributes["Temperature"]; AFEnumerationValue digSetValue = i % 2 == 0 ? digSet["Auto"] : digSet["Manual"]; AFValue afValueDigital = new AFValue(digSetValue, time); afValueDigital.Attribute = boilerA.Attributes["Mode"]; valuesToWrite.Add(afValueFloat); valuesToWrite.Add(afValueDigital); } // Perform a bulk write. Use a single local call to PI Buffer Subsystem if possible. // Otherwise, make a single call to the PI Data Archive. // We use no compression just so we can check all the values are written. // AFListData is the class that provides the bulk write method. AFListData.UpdateValues(valuesToWrite, AFUpdateOption.InsertNoCompression, AFBufferOption.BufferIfPossible); }
//PIPoints /// <summary> /// Accesses the PIServer to get the PIPoints that are available. /// </summary> /// <param name="sys"> The current PISystem</param> /// <param name="serv"> The current PIServer</param> /// <returns></returns> public List <PIPoint> getPIPoints(PISystem sys, PIServer serv) { mainForm.Status("Getting PIPoints..."); currentSystem = sys; currentPIServer = serv; List <PIPoint> list; try { List <string> query = new List <string>() { "*" }; list = (List <PIPoint>)PIPoint.FindPIPoints(serv, query, null); return(list); } catch { mainForm.Status("ERROR: Unable to attach to " + serv.Name); return(null); } }
static void PrintEnergyUOMs(PISystem system) { try { Console.WriteLine("Print Energy UOMS"); UOMClass uomClass = system.UOMDatabase.UOMClasses["Specific Entropy, Specific Heat Capacity"]; foreach (UOM uom in uomClass.UOMs) { Console.WriteLine("UOM: {0}, Abbrevation: {1}", uom.Name, uom.Abbreviation); } Console.WriteLine(); } catch (Exception ex) { Logs Err = new Logs(); Err.MyLogFile(ex); Console.WriteLine("An Error has occured for details please check the Log File: '" + ex.Message + "'"); Console.ReadLine(); } }
public WAFElement() { PISystems syss = new PISystems(); m_piSys = syss.DefaultPISystem; m_afDb = m_piSys.Databases.DefaultDatabase; }
public UOMManager(PISystem piSystem) { this.piSystem = piSystem; }
static void PrintEnergyUOMs(PISystem system) { // Your code here }
// Define other instance members here public AFHierarchyBuilder(string server) { _piSystem = new PISystems()[server]; }
//PIPoints /// <summary> /// Accesses the PIServer to get the PIPoints that are available. /// </summary> /// <param name="sys"> The current PISystem</param> /// <param name="serv"> The current PIServer</param> /// <returns></returns> public List<PIPoint> getPIPoints(PISystem sys, PIServer serv) { mainForm.Status("Getting PIPoints..."); currentSystem = sys; currentPIServer = serv; List<PIPoint> list; try { List<string> query = new List<string>() { "*" }; list = (List<PIPoint>)PIPoint.FindPIPoints(serv, query, null); return list; } catch { mainForm.Status("ERROR: Unable to attach to " + serv.Name); return null; } }