/// <summary> /// Bind each TCD_Interface node to separate TCDSimulator. /// </summary> protected override NodeState AddBehaviourToPredefinedNode(ISystemContext context, NodeState predefinedNode) { BaseObjectState passiveNode = predefinedNode as BaseObjectState; if (passiveNode != null) { NodeId typeId = passiveNode.TypeDefinitionId; if (IsNodeIdInNamespace(typeId) && typeId.IdType == IdType.Numeric && (uint)typeId.Identifier == ObjectTypes.TCD_Interface) { // Found a TCD_Interface. If it is not already an active node, then replace it with one. TCD_InterfaceState activeNode = passiveNode as TCD_InterfaceState; if (activeNode == null) { activeNode = new TCD_InterfaceState(passiveNode.Parent); activeNode.Create(context, passiveNode); if (passiveNode.Parent != null) { passiveNode.Parent.ReplaceChild(context, activeNode); } } // Now that we have an active node, bind it to a simulator. TCDSimulator simulator = CreateSimulatorForNode(activeNode); if (simulator != null) { simulator.AddListener(activeNode); simulator.SetLogger(m_Logger); simulator.StartSimulation(); m_Simulators.Add(simulator); // Prevent it from being disposed } return(activeNode); } } return(predefinedNode); }
public void SyncWith(TCDSimulator simulator) { // Update DeviceClass. if (!String.Equals(m_deviceClass.Value, simulator.DeviceClass)) { m_deviceClass.Value = simulator.DeviceClass; m_deviceClass.UpdateChangeMasks(NodeStateChangeMasks.Value); } // Update Manufacturer. if (!String.Equals(m_manufacturer.Value, simulator.GetManufacturer())) { m_manufacturer.Value = simulator.GetManufacturer(); m_manufacturer.UpdateChangeMasks(NodeStateChangeMasks.Value); } // Update Model. if (!String.Equals(m_model.Value, simulator.GetModel())) { m_model.Value = simulator.GetModel(); m_model.UpdateChangeMasks(NodeStateChangeMasks.Value); } // Update SerialNumber. if (!String.Equals(m_serialNumber.Value, simulator.SerialNumber)) { m_serialNumber.Value = simulator.SerialNumber; m_serialNumber.UpdateChangeMasks(NodeStateChangeMasks.Value); } }
/// <summary> /// Notification method that is called when the simulator state changes. /// </summary> /// <param name="simulator"></param> public void Notify(TCDSimulator simulator) { m_deviceZone.SyncWith(simulator); m_identification.SyncWith(simulator); m_machineConfiguration.SyncWith(simulator); m_operation.SyncWith(simulator); m_tCDSpecification.SyncWith(simulator); ClearChangeMasks(new SystemContext(), true); }
public void SyncWith(TCDSimulator simulator) { // Update ConnectedLoad. double connectedLoad = simulator.GetConnectedLoad(); if (!(m_connectedLoad.Value is double) || (double)m_connectedLoad.Value != connectedLoad) { m_connectedLoad.Value = connectedLoad; m_connectedLoad.UpdateChangeMasks(NodeStateChangeMasks.Value); } // Update CoolingCapacity. double coolingCapacity = simulator.GetCoolingCapacity_W() / 1000.0; if (!(m_coolingCapacity.Value is double) || (double)m_coolingCapacity.Value != connectedLoad) { m_coolingCapacity.Value = coolingCapacity; m_coolingCapacity.EngineeringUnits = new PropertyState <EUInformation>(m_coolingCapacity); m_coolingCapacity.EngineeringUnits.Value = new EUInformation("W", "uri"); m_coolingCapacity.UpdateChangeMasks(NodeStateChangeMasks.Value); } // Update MaxTemperature double maxTemperature = simulator.GetMaxTemperature_C(); if (!(m_maxTemperature.Value is double) || (double)m_maxTemperature.Value != maxTemperature) { m_maxTemperature.Value = maxTemperature; m_maxTemperature.UpdateChangeMasks(NodeStateChangeMasks.Value); } // Update MinTemperature double minTemperature = simulator.GetMinTemperature_C(); if (!(m_minTemperature.Value is double) || (double)m_minTemperature.Value != minTemperature) { m_minTemperature.Value = minTemperature; m_minTemperature.UpdateChangeMasks(NodeStateChangeMasks.Value); } // Update PowerValue double power = simulator.GetHeatingPower_W() / 1000.0; if (!(m_powerValue.Value is double) || (double)m_powerValue.Value != minTemperature) { m_powerValue.Value = power; m_powerValue.UpdateChangeMasks(NodeStateChangeMasks.Value); } }
public void SyncWith(TCDSimulator simulator) { // Synchronise UserMachineName. string machineName = simulator.GetUserMachineName(); if (simulator.HasUserMachineNameChanged()) { m_userMachineName.Value = machineName; m_userMachineName.UpdateChangeMasks(NodeStateChangeMasks.Value); } else if (m_userMachineName.Value is string && (string)m_userMachineName.Value != machineName) { simulator.SetUserMachineName((string)m_userMachineName.Value, true); } // Synchronise LocationName. string locationName = simulator.GetLocationName(); if (simulator.HasLocationNameChanged()) { m_locationName.Value = locationName; m_locationName.UpdateChangeMasks(NodeStateChangeMasks.Value); } else if (m_locationName.Value is string && (string)m_locationName.Value != locationName) { simulator.SetLocationName((string)m_locationName.Value, true); } // Update TimeZoneOffset. if (m_timeZoneOffset.Value == null) { m_timeZoneOffset.Value = new TimeZoneDataType(); m_timeZoneOffset.UpdateChangeMasks(NodeStateChangeMasks.Value); } if (m_timeZoneOffset.Value.offset != simulator.TimeZoneOffset) { m_timeZoneOffset.Value.offset = simulator.TimeZoneOffset; m_timeZoneOffset.UpdateChangeMasks(NodeStateChangeMasks.Value); } if (m_timeZoneOffset.Value.daylightSavingInOffset != simulator.DaylightSavingsInOffset) { m_timeZoneOffset.Value.daylightSavingInOffset = simulator.DaylightSavingsInOffset; m_timeZoneOffset.UpdateChangeMasks(NodeStateChangeMasks.Value); } }
public void setSimulator(TCDSimulator simulator) { m_simulator = simulator; }
/// <summary> /// Synchronise the DeviceZone information in the OPC UA information model with the current state of a /// Temperature Control Device simulator. For read-write fields the synchronisation is bidirectional: if the /// simulator indicates that the value has changed, then the OPC UA information model is updated; otherwise /// if the value in the information model is different from that in the simulator, then the simulator is /// upated with the new value. Read-only fields are updated from the simulator if the value has changed. /// </summary> /// <param name="simulator">The simulator to sync with.</param> public void SyncWith(TCDSimulator simulator) { // Update Temperature.ActualValue. double actualTemp = simulator.GetActualTemp_C(); if (!(m_temperature.ActualValue.Value is double) || (double)m_temperature.ActualValue.Value != actualTemp) { m_temperature.ActualValue.Value = actualTemp; if (m_temperature.ActualValue.EngineeringUnits == null) { m_temperature.ActualValue.EngineeringUnits = new PropertyState <EUInformation>(m_temperature.ActualValue); } m_temperature.ActualValue.EngineeringUnits.Value = new EUInformation("C", "Degrees Centigrade", @"http://www.opcfoundation.org/UA/units/un/cefact"); m_temperature.ActualValue.UpdateChangeMasks(NodeStateChangeMasks.Value); } // Synchronise Temperature.SetValue. double setpoint = simulator.GetSetpoint_C(); if (simulator.HasSetpointChanged()) { m_temperature.SetValue.Value = setpoint; m_temperature.SetValue.UpdateChangeMasks(NodeStateChangeMasks.Value); } else if (m_temperature.SetValue.Value is double && (double)m_temperature.SetValue.Value != setpoint) { simulator.SetSetpoint((double)m_temperature.SetValue.Value, true); } // Synchronise Temperature.SetRampUp. double rampUp = simulator.GetRampUp_CpMin(); if (simulator.HasRampUpChanged()) { m_temperature.SetRampUp.Value = rampUp; m_temperature.SetRampUp.UpdateChangeMasks(NodeStateChangeMasks.Value); } else if (m_temperature.SetRampUp.Value is double && (double)m_temperature.SetRampUp.Value != rampUp) { simulator.SetRampUp((double)m_temperature.SetRampUp.Value, true); } // Synchronise Temperature.SetRampDown. double rampDown = simulator.GetRampDown_CpMin(); if (simulator.HasRampDownChanged()) { m_temperature.SetRampDown.Value = rampDown; m_temperature.SetRampDown.UpdateChangeMasks(NodeStateChangeMasks.Value); } else if (m_temperature.SetRampDown.Value is double && (double)m_temperature.SetRampDown.Value != rampDown) { simulator.SetRampDown((double)m_temperature.SetRampDown.Value, true); } // Synchronise Temperature.LowerTolerance. double lowerTolerance = simulator.GetLowerTolerance_C(); if (simulator.HasLowerToleranceChanged()) { m_temperature.LowerTolerance.Value = lowerTolerance; m_temperature.LowerTolerance.UpdateChangeMasks(NodeStateChangeMasks.Value); } else if (m_temperature.LowerTolerance.Value is double && (double)m_temperature.LowerTolerance.Value != lowerTolerance) { simulator.SetLowerTolerance((double)m_temperature.LowerTolerance.Value, true); } // Synchroise Temperature.UpperTolerance. double upperTolerance = simulator.GetUpperTolerance_C(); if (simulator.HasUpperToleranceChanged()) { m_temperature.UpperTolerance.Value = upperTolerance; m_temperature.UpperTolerance.UpdateChangeMasks(NodeStateChangeMasks.Value); } else if (m_temperature.UpperTolerance.Value is double && (double)m_temperature.UpperTolerance.Value != upperTolerance) { simulator.SetUpperTolerance((double)m_temperature.UpperTolerance.Value, true); } // Synchronise Temperature.MinValue. double minValue = simulator.GetMinValue_C(); if (simulator.HasMinValueChanged()) { m_temperature.MinValue.Value = minValue; m_temperature.MinValue.UpdateChangeMasks(NodeStateChangeMasks.Value); } else if (m_temperature.MinValue.Value is double && (double)m_temperature.MinValue.Value != minValue) { simulator.SetMinValue((double)m_temperature.MinValue.Value, true); } // Synchronise Temperature.MaxValue. double maxValue = simulator.GetMaxValue_C(); if (simulator.HasMaxValueChanged()) { m_temperature.MaxValue.Value = maxValue; m_temperature.MaxValue.UpdateChangeMasks(NodeStateChangeMasks.Value); } else if (m_temperature.MaxValue.Value is double && (double)m_temperature.MaxValue.Value != maxValue) { simulator.SetMaxValue((double)m_temperature.MaxValue.Value, true); } if (m_maintenanceInformation != null) { // Synchronise MaintenanceInformation Cooling. if (m_maintenanceInformation.Cooling != null) { m_maintenanceInformation.Cooling.SyncWith(simulator.CoolingMaintenance); if (!(m_maintenanceInformation.Cooling.Reset is ResetCoolingMaintenanceMethodState)) { ResetCoolingMaintenanceMethodState method = new ResetCoolingMaintenanceMethodState(m_maintenanceInformation.Cooling.Reset); method.setSimulator(simulator); m_maintenanceInformation.Cooling.Reset = method; } } // Synchronise MaintenanceInformation Heating. if (m_maintenanceInformation.Heating != null) { m_maintenanceInformation.Heating.SyncWith(simulator.HeatingMaintenance); if (!(m_maintenanceInformation.Heating.Reset is ResetHeatingMethodState)) { ResetHeatingMethodState method = new ResetHeatingMethodState(m_maintenanceInformation.Heating.Reset); method.setSimulator(simulator); m_maintenanceInformation.Heating.Reset = method; } } } }
public void SyncWith(TCDSimulator simulator) { // Update HoursOfOperation. double hoursOfOperation = simulator.GetHoursOfOperation(); if (!(m_hoursOfOperation.Value is double) || (double)m_hoursOfOperation.Value != hoursOfOperation) { m_hoursOfOperation.Value = hoursOfOperation; m_hoursOfOperation.UpdateChangeMasks(NodeStateChangeMasks.Value); } // Update DeviceMappingNumber. if (m_deviceMappingNumber.Value != simulator.DeviceMappingNumber) { m_deviceMappingNumber.Value = simulator.DeviceMappingNumber; m_deviceMappingNumber.UpdateChangeMasks(NodeStateChangeMasks.Value); } // Update OperatingMode. if (!String.Equals(m_operatingMode.Value, simulator.GetOperatingMode())) { m_operatingMode.Value = simulator.GetOperatingMode(); m_operatingMode.UpdateChangeMasks(NodeStateChangeMasks.Value); } // If the SwitchOn method has been invoked replace the generated method state with // one that will switch on this TCD. if (!(m_switchOnMethod is SwitchOnMethodState)) { SwitchOnMethodState method = new SwitchOnMethodState(m_switchOnMethod); method.setSimulator(simulator); m_switchOnMethod = method; } // If the SwitchOff method has been invoked replace the generated method state with // one that will switch off this TCD. if (!(m_switchOffMethod is SwitchOffMethodState)) { SwitchOffMethodState method = new SwitchOffMethodState(m_switchOffMethod); method.setSimulator(simulator); m_switchOffMethod = method; } // If the ResetAllErrors method has been invoked, then replace the generated // method state with one that will reset errors for this TCD. if (!(m_resetAllErrorsMethod is ResetAllErrorsMethodState)) { ResetAllErrorsMethodState method = new ResetAllErrorsMethodState(m_resetAllErrorsMethod); method.setSimulator(simulator); m_resetAllErrorsMethod = method; } // Update ActiveErrors. if (m_activeErrors.Value == null || simulator.HasActiveErrorsChanged()) { m_activeErrors.Value = simulator.GetActiveErrors(); m_highestActiveAlarmSeverity.Value = 0; for (int errorIndex = 0; errorIndex < m_activeErrors.Value.Length; errorIndex++) { if (m_activeErrors.Value[errorIndex].Severity > m_highestActiveAlarmSeverity.Value) { m_highestActiveAlarmSeverity.Value = m_activeErrors.Value[errorIndex].Severity; } } m_activeErrors.UpdateChangeMasks(NodeStateChangeMasks.Value); m_highestActiveAlarmSeverity.UpdateChangeMasks(NodeStateChangeMasks.Value); } }