|
@@ -0,0 +1,560 @@
|
|
|
+/******************************************************************************
|
|
|
+** Copyright (c) 2006-2018 Unified Automation GmbH All rights reserved.
|
|
|
+**
|
|
|
+** Software License Agreement ("SLA") Version 2.7
|
|
|
+**
|
|
|
+** Unless explicitly acquired and licensed from Licensor under another
|
|
|
+** license, the contents of this file are subject to the Software License
|
|
|
+** Agreement ("SLA") Version 2.7, or subsequent versions
|
|
|
+** as allowed by the SLA, and You may not copy or use this file in either
|
|
|
+** source code or executable form, except in compliance with the terms and
|
|
|
+** conditions of the SLA.
|
|
|
+**
|
|
|
+** All software distributed under the SLA is provided strictly on an
|
|
|
+** "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
|
|
|
+** AND LICENSOR HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
|
|
|
+** LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
|
|
+** PURPOSE, QUIET ENJOYMENT, OR NON-INFRINGEMENT. See the SLA for specific
|
|
|
+** language governing rights and limitations under the SLA.
|
|
|
+**
|
|
|
+** Project: .NET based OPC UA Client Server SDK
|
|
|
+**
|
|
|
+** Description: OPC Unified Architecture Software Development Kit.
|
|
|
+**
|
|
|
+** The complete license agreement can be found here:
|
|
|
+** http://unifiedautomation.com/License/SLA/2.7/
|
|
|
+******************************************************************************/
|
|
|
+
|
|
|
+using System;
|
|
|
+using System.Collections.Generic;
|
|
|
+using System.Linq;
|
|
|
+using System.Text;
|
|
|
+using System.Threading;
|
|
|
+using System.IO;
|
|
|
+using System.Reflection;
|
|
|
+using System.Xml;
|
|
|
+using System.Xml.Serialization;
|
|
|
+using UnifiedAutomation.UaBase;
|
|
|
+using UnifiedAutomation.UaServer;
|
|
|
+
|
|
|
+namespace YourCompany.GettingStarted
|
|
|
+{
|
|
|
+ /// <summary>
|
|
|
+ /// A class that provides access to the underlying system.
|
|
|
+ /// </summary>
|
|
|
+ public class UnderlyingSystem : IDisposable
|
|
|
+ {
|
|
|
+ #region Constructors
|
|
|
+ /// <summary>
|
|
|
+ /// Initializes a new instance of the <see cref="UnderlyingSystem"/> class.
|
|
|
+ /// </summary>
|
|
|
+ public UnderlyingSystem()
|
|
|
+ {
|
|
|
+ m_registers = new byte[4096];
|
|
|
+ m_blocks = new Dictionary<int, BlockConfiguration>();
|
|
|
+ }
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region IDisposable Members
|
|
|
+ /// <summary>
|
|
|
+ /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
|
|
|
+ /// </summary>
|
|
|
+ public void Dispose()
|
|
|
+ {
|
|
|
+ Dispose(true);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Releases unmanaged and - optionally - managed resources
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
|
|
|
+ protected void Dispose(bool disposing)
|
|
|
+ {
|
|
|
+ if (disposing)
|
|
|
+ {
|
|
|
+ if (m_simulationTimer != null)
|
|
|
+ {
|
|
|
+ m_simulationTimer.Dispose();
|
|
|
+ m_simulationTimer = null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region Public Methods
|
|
|
+ /// <summary>
|
|
|
+ /// Initializes this instance.
|
|
|
+ /// </summary>
|
|
|
+ public void Initialize()
|
|
|
+ {
|
|
|
+ // load the configuration file.
|
|
|
+ Load();
|
|
|
+
|
|
|
+ // start the simulation timer.
|
|
|
+ m_simulationTimer = new Timer(DoSimulation, null, 1000, 1000);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Gets the blockAddress configurations.
|
|
|
+ /// </summary>
|
|
|
+ /// <returns></returns>
|
|
|
+ public IEnumerable<BlockConfiguration> GetBlocks()
|
|
|
+ {
|
|
|
+ return m_blocks.Values;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Reads the tag value.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="blockAddress">The blockAddress.</param>
|
|
|
+ /// <param name="tag">The tag.</param>
|
|
|
+ /// <returns>The value. null if no value exists.</returns>
|
|
|
+ public object Read(int blockAddress, int tag)
|
|
|
+ {
|
|
|
+ lock (m_lock)
|
|
|
+ {
|
|
|
+ if (blockAddress < 0 || tag < 0)
|
|
|
+ {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (blockAddress + tag > m_position - sizeof(int))
|
|
|
+ {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ BlockConfiguration controller = null;
|
|
|
+
|
|
|
+ if (!m_blocks.TryGetValue(blockAddress, out controller))
|
|
|
+ {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ foreach (BlockProperty property in controller.Properties)
|
|
|
+ {
|
|
|
+ if (property.Offset == tag)
|
|
|
+ {
|
|
|
+ if (property.DataType == DataTypeIds.Double)
|
|
|
+ {
|
|
|
+ return (double)BitConverter.ToSingle(m_registers, blockAddress + tag);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (property.DataType == DataTypeIds.Int32)
|
|
|
+ {
|
|
|
+ return BitConverter.ToInt32(m_registers, blockAddress + tag);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Writes the tag value.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="blockAddress">The blockAddress.</param>
|
|
|
+ /// <param name="tag">The tag.</param>
|
|
|
+ /// <param name="value">The value.</param>
|
|
|
+ /// <returns>
|
|
|
+ /// True if the write was successful.
|
|
|
+ /// </returns>
|
|
|
+ public bool Write(int blockAddress, int tag, object value)
|
|
|
+ {
|
|
|
+ lock (m_lock)
|
|
|
+ {
|
|
|
+ if (blockAddress < 0 || tag < 0)
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (blockAddress + tag > m_position - sizeof(int))
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ BlockConfiguration controller = null;
|
|
|
+
|
|
|
+ if (!m_blocks.TryGetValue(blockAddress, out controller))
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ foreach (BlockProperty property in controller.Properties)
|
|
|
+ {
|
|
|
+ if (property.Offset == tag)
|
|
|
+ {
|
|
|
+ if (!property.Writeable)
|
|
|
+ {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (property.DataType == DataTypeIds.Double)
|
|
|
+ {
|
|
|
+ Write(blockAddress, tag, (double)value);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (property.DataType == DataTypeIds.Int32)
|
|
|
+ {
|
|
|
+ Write(blockAddress, tag, (int)value);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Starts the specified object id.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="blockAddress">The blockAddress.</param>
|
|
|
+ /// <returns></returns>
|
|
|
+ public StatusCode Start(int blockAddress)
|
|
|
+ {
|
|
|
+ lock (m_lock)
|
|
|
+ {
|
|
|
+ BlockConfiguration controller = null;
|
|
|
+
|
|
|
+ if (!m_blocks.TryGetValue(blockAddress, out controller))
|
|
|
+ {
|
|
|
+ return StatusCodes.BadNodeIdUnknown;
|
|
|
+ }
|
|
|
+
|
|
|
+ foreach (BlockProperty property in controller.Properties)
|
|
|
+ {
|
|
|
+ if (property.Name == "State")
|
|
|
+ {
|
|
|
+ Write(blockAddress, property.Offset, (int)1);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return StatusCodes.Good;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Stops the specified object id.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="blockAddress">The blockAddress.</param>
|
|
|
+ /// <returns></returns>
|
|
|
+ public StatusCode Stop(int blockAddress)
|
|
|
+ {
|
|
|
+ lock (m_lock)
|
|
|
+ {
|
|
|
+ BlockConfiguration controller = null;
|
|
|
+
|
|
|
+ if (!m_blocks.TryGetValue(blockAddress, out controller))
|
|
|
+ {
|
|
|
+ return StatusCodes.BadNodeIdUnknown;
|
|
|
+ }
|
|
|
+
|
|
|
+ foreach (BlockProperty property in controller.Properties)
|
|
|
+ {
|
|
|
+ if (property.Name == "State")
|
|
|
+ {
|
|
|
+ Write(blockAddress, property.Offset, (int)0);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return StatusCodes.Good;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Called when to start the simulation with a set point.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="blockAddress">The blockAddress.</param>
|
|
|
+ /// <param name="temperatureSetPoint">The temperature set point.</param>
|
|
|
+ /// <param name="humditySetPoint">The humdity set point.</param>
|
|
|
+ /// <returns></returns>
|
|
|
+ public StatusCode StartWithSetPoint(int blockAddress, double temperatureSetPoint, double humditySetPoint)
|
|
|
+ {
|
|
|
+ lock (m_lock)
|
|
|
+ {
|
|
|
+ BlockConfiguration controller = null;
|
|
|
+
|
|
|
+ if (!m_blocks.TryGetValue(blockAddress, out controller))
|
|
|
+ {
|
|
|
+ return StatusCodes.BadNodeIdUnknown;
|
|
|
+ }
|
|
|
+
|
|
|
+ foreach (BlockProperty property in controller.Properties)
|
|
|
+ {
|
|
|
+ if (property.Name == "TemperatureSetPoint")
|
|
|
+ {
|
|
|
+ Write(blockAddress, property.Offset, temperatureSetPoint);
|
|
|
+ }
|
|
|
+
|
|
|
+ else if (property.Name == "HumiditySetPoint")
|
|
|
+ {
|
|
|
+ Write(blockAddress, property.Offset, humditySetPoint);
|
|
|
+ }
|
|
|
+
|
|
|
+ else if (property.Name == "State")
|
|
|
+ {
|
|
|
+ Write(blockAddress, property.Offset, (int)1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return StatusCodes.Good;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region Private Method
|
|
|
+ /// <summary>
|
|
|
+ /// Loads the configuration for the system.
|
|
|
+ /// </summary>
|
|
|
+ private void Load()
|
|
|
+ {
|
|
|
+ foreach (string resourceName in Assembly.GetExecutingAssembly().GetManifestResourceNames())
|
|
|
+ {
|
|
|
+ if (resourceName.EndsWith(".SystemConfiguration.xml"))
|
|
|
+ {
|
|
|
+ using (Stream istrm = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName))
|
|
|
+ {
|
|
|
+ XmlSerializer serializer = new XmlSerializer(typeof(Configuration));
|
|
|
+ m_configuration = (Configuration)serializer.Deserialize(istrm);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (m_configuration.Controllers != null)
|
|
|
+ {
|
|
|
+ for (int ii = 0; ii < m_configuration.Controllers.Length; ii++)
|
|
|
+ {
|
|
|
+ ControllerConfiguration controller = m_configuration.Controllers[ii];
|
|
|
+
|
|
|
+ int blockAddress = m_position;
|
|
|
+ int offset = m_position - blockAddress;
|
|
|
+
|
|
|
+ BlockConfiguration data = new BlockConfiguration()
|
|
|
+ {
|
|
|
+ Address = blockAddress,
|
|
|
+ Name = controller.Name,
|
|
|
+ Type = controller.Type,
|
|
|
+ Properties = new List<BlockProperty>()
|
|
|
+ };
|
|
|
+
|
|
|
+ if (controller.Properties != null)
|
|
|
+ {
|
|
|
+ for (int jj = 0; jj < controller.Properties.Length; jj++)
|
|
|
+ {
|
|
|
+ ControllerProperty property = controller.Properties[jj];
|
|
|
+ NodeId dataTypeId = NodeId.Parse(property.DataType);
|
|
|
+ string value = property.Value;
|
|
|
+ Range range = null;
|
|
|
+
|
|
|
+ if (!String.IsNullOrEmpty(property.Range))
|
|
|
+ {
|
|
|
+ try
|
|
|
+ {
|
|
|
+ NumericRange nr = NumericRange.Parse(property.Range);
|
|
|
+ range = new Range() { High = nr.End, Low = nr.Begin };
|
|
|
+ }
|
|
|
+ catch (Exception)
|
|
|
+ {
|
|
|
+ range = null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ data.Properties.Add(new BlockProperty()
|
|
|
+ {
|
|
|
+ Offset = offset,
|
|
|
+ Name = controller.Properties[jj].Name,
|
|
|
+ DataType = dataTypeId,
|
|
|
+ Writeable = controller.Properties[jj].Writeable,
|
|
|
+ Range = range
|
|
|
+ });
|
|
|
+
|
|
|
+ switch ((uint)dataTypeId.Identifier)
|
|
|
+ {
|
|
|
+ case DataTypes.Int32:
|
|
|
+ {
|
|
|
+ Write(blockAddress, offset, (int)TypeUtils.Cast(value, BuiltInType.Int32));
|
|
|
+ offset += 4;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ case DataTypes.Double:
|
|
|
+ {
|
|
|
+ Write(blockAddress, offset, (double)TypeUtils.Cast(value, BuiltInType.Double));
|
|
|
+ offset += 4;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ m_position += offset;
|
|
|
+ m_blocks[blockAddress] = data;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Writes the specified offset.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="offset">The offset.</param>
|
|
|
+ /// <param name="value">The value.</param>
|
|
|
+ private void Write(int blockAddress, int offset, int value)
|
|
|
+ {
|
|
|
+ byte[] bytes = BitConverter.GetBytes(value);
|
|
|
+ Array.Copy(bytes, 0, m_registers, blockAddress + offset, bytes.Length);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Writes the specified offset.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="offset">The offset.</param>
|
|
|
+ /// <param name="value">The value.</param>
|
|
|
+ private void Write(int blockAddress, int offset, double value)
|
|
|
+ {
|
|
|
+ byte[] bytes = BitConverter.GetBytes((float)value);
|
|
|
+ Array.Copy(bytes, 0, m_registers, blockAddress + offset, bytes.Length);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Does the simulation.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="state">The state.</param>
|
|
|
+ private void DoSimulation(object state)
|
|
|
+ {
|
|
|
+ try
|
|
|
+ {
|
|
|
+ lock (m_lock)
|
|
|
+ {
|
|
|
+ foreach (var blockAddress in m_blocks)
|
|
|
+ {
|
|
|
+ for (int ii = 0; ii < blockAddress.Value.Properties.Count - 1; ii++)
|
|
|
+ {
|
|
|
+ string firstName = blockAddress.Value.Properties[ii].Name;
|
|
|
+ string secondName = blockAddress.Value.Properties[ii + 1].Name;
|
|
|
+
|
|
|
+ if (!secondName.StartsWith(firstName) || !secondName.EndsWith("SetPoint"))
|
|
|
+ {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ int valueOffset = blockAddress.Value.Properties[ii].Offset;
|
|
|
+ int setpointOffset = blockAddress.Value.Properties[ii + 1].Offset;
|
|
|
+
|
|
|
+ double value = (double)Read(blockAddress.Key, valueOffset);
|
|
|
+ double setpoint = (double)Read(blockAddress.Key, setpointOffset);
|
|
|
+
|
|
|
+ Write(blockAddress.Key, valueOffset, Adjust(value, setpoint));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ catch (Exception e)
|
|
|
+ {
|
|
|
+ TraceServer.Error(e, "Failed run simulation.");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Adjusts the specified value.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="value">The value.</param>
|
|
|
+ /// <param name="setPoint">The set point.</param>
|
|
|
+ /// <returns></returns>
|
|
|
+ private double Adjust(double value, double setPoint)
|
|
|
+ {
|
|
|
+ Random random = new Random();
|
|
|
+ double delta = (Math.Abs(setPoint - value) + 1) * random.NextDouble();
|
|
|
+ return value + ((random.Next() % 2 == 0) ? delta : -delta);
|
|
|
+ }
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region Configuration File Classes
|
|
|
+ [XmlType(TypeName = "UnderlyingSystem.ControllerProperty", Namespace = "http://yourcompany.com/underlyingsystem")]
|
|
|
+ public class ControllerProperty
|
|
|
+ {
|
|
|
+ [XmlElement(Order = 1)]
|
|
|
+ public string Name { get; set; }
|
|
|
+
|
|
|
+ [XmlElement(Order = 2)]
|
|
|
+ public string DataType { get; set; }
|
|
|
+
|
|
|
+ [XmlElement(Order = 3)]
|
|
|
+ public string Value { get; set; }
|
|
|
+
|
|
|
+ [XmlElement(Order = 4)]
|
|
|
+ public bool Writeable { get; set; }
|
|
|
+
|
|
|
+ [XmlElement(Order = 5)]
|
|
|
+ public string Range { get; set; }
|
|
|
+ }
|
|
|
+
|
|
|
+ [XmlType(TypeName = "UnderlyingSystem.ControllerConfiguration", Namespace = "http://yourcompany.com/underlyingsystem")]
|
|
|
+ public class ControllerConfiguration
|
|
|
+ {
|
|
|
+ [XmlElement(Order = 1)]
|
|
|
+ public string Name { get; set; }
|
|
|
+
|
|
|
+ [XmlElement(Order = 2)]
|
|
|
+ public int Type { get; set; }
|
|
|
+
|
|
|
+ [XmlElement(Order = 3)]
|
|
|
+ public ControllerProperty[] Properties;
|
|
|
+ }
|
|
|
+
|
|
|
+ [XmlRoot(ElementName = "UnderlyingSystem.Configuration", Namespace = "http://yourcompany.com/underlyingsystem")]
|
|
|
+ public class Configuration
|
|
|
+ {
|
|
|
+ [XmlElement(Order = 1)]
|
|
|
+ public ControllerConfiguration[] Controllers;
|
|
|
+ }
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region Private Fields
|
|
|
+ private object m_lock = new object();
|
|
|
+ private byte[] m_registers;
|
|
|
+ private int m_position;
|
|
|
+ private Dictionary<int, BlockConfiguration> m_blocks;
|
|
|
+ private Configuration m_configuration;
|
|
|
+ private Timer m_simulationTimer;
|
|
|
+ #endregion
|
|
|
+ }
|
|
|
+
|
|
|
+ #region BlockProperty Class
|
|
|
+ /// <summary>
|
|
|
+ /// The configuration for a property of a blockAddress.
|
|
|
+ /// </summary>
|
|
|
+ public class BlockProperty
|
|
|
+ {
|
|
|
+ public int Offset;
|
|
|
+ public string Name;
|
|
|
+ public NodeId DataType;
|
|
|
+ public bool Writeable;
|
|
|
+ public Range Range;
|
|
|
+ }
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region BlockConfiguration Class
|
|
|
+ /// <summary>
|
|
|
+ /// The configuration for a blockAddress.
|
|
|
+ /// </summary>
|
|
|
+ public class BlockConfiguration
|
|
|
+ {
|
|
|
+ public int Address;
|
|
|
+ public string Name;
|
|
|
+ public int Type;
|
|
|
+ public List<BlockProperty> Properties;
|
|
|
+ }
|
|
|
+ #endregion
|
|
|
+
|
|
|
+ #region BlockType Class
|
|
|
+ public static class BlockType
|
|
|
+ {
|
|
|
+ public const int AirConditioner = 1;
|
|
|
+ public const int Furnace = 2;
|
|
|
+ }
|
|
|
+ #endregion
|
|
|
+}
|