public Dictionary<Topic, SCADAPublication> GetIntegrityUpdate()
{
if (IntegrityUpdateService.scadaModel == null)
{
string message = $"GetIntegrityUpdate => SCADA model is null.";
Logger.LogError(message);
throw new InternalSCADAServiceException(message);
}
var currentScadaModel = IntegrityUpdateService.scadaModel.CurrentScadaModel;
var commandValuesCache = IntegrityUpdateService.scadaModel.CommandedValuesCache;
Dictionary<long, AnalogModbusData> analogModbusData = new Dictionary<long, AnalogModbusData>();
Dictionary<long, DiscreteModbusData> discreteModbusData = new Dictionary<long, DiscreteModbusData>();
foreach(long gid in currentScadaModel.Keys)
{
CommandOriginType commandOrigin = CommandOriginType.OTHER_COMMAND;
if (currentScadaModel[gid] is AnalogSCADAModelPointItem analogPointItem)
{
if (commandValuesCache.ContainsKey(gid) && commandValuesCache[gid].Value == analogPointItem.CurrentRawValue)
{
commandOrigin = commandValuesCache[gid].CommandOrigin;
}
AnalogModbusData analogValue = new AnalogModbusData(analogPointItem.CurrentEguValue, analogPointItem.Alarm, gid, commandOrigin);
analogModbusData.Add(gid, analogValue);
}
else if(currentScadaModel[gid] is DiscreteSCADAModelPointItem discretePointItem)
{
if (commandValuesCache.ContainsKey(gid) && commandValuesCache[gid].Value == discretePointItem.CurrentValue)
{
commandOrigin = commandValuesCache[gid].CommandOrigin;
}
DiscreteModbusData discreteValue = new DiscreteModbusData(discretePointItem.CurrentValue, discretePointItem.Alarm, gid, commandOrigin);
discreteModbusData.Add(gid, discreteValue);
}
}
MultipleAnalogValueSCADAMessage analogValuesMessage = new MultipleAnalogValueSCADAMessage(analogModbusData);
SCADAPublication measurementPublication = new SCADAPublication(Topic.MEASUREMENT, analogValuesMessage);
MultipleDiscreteValueSCADAMessage discreteValuesMessage = new MultipleDiscreteValueSCADAMessage(discreteModbusData);
SCADAPublication switchStatusPublication = new SCADAPublication(Topic.SWITCH_STATUS, discreteValuesMessage);
Dictionary<Topic, SCADAPublication> scadaPublications = new Dictionary<Topic, SCADAPublication>
{
{ Topic.MEASUREMENT, measurementPublication },
{ Topic.SWITCH_STATUS, switchStatusPublication },
};
return scadaPublications;
}
private void PublishScadaData(Topic topic, SCADAMessage scadaMessage)
{
SCADAPublication scadaPublication = new SCADAPublication(topic, scadaMessage);
using (PublisherProxy publisherProxy = proxyFactory.CreateProxy <PublisherProxy, IPublisher>(EndpointNames.PublisherEndpoint))
{
if (publisherProxy == null)
{
string errMsg = "PublisherProxy is null.";
Logger.LogWarn(errMsg);
throw new NullReferenceException(errMsg);
}
publisherProxy.Publish(scadaPublication, "SCADA_PUBLISHER");
Logger.LogInfo($"SCADA service published data from topic: {scadaPublication.Topic}");
StringBuilder sb = new StringBuilder();
sb.AppendLine("MeasurementCache content: ");
foreach (long gid in MeasurementsCache.Keys)
{
IModbusData data = MeasurementsCache[gid];
if (data is AnalogModbusData analogModbusData)
{
sb.AppendLine($"Analog data line: [gid] 0x{gid:X16}, [value] {analogModbusData.Value}, [alarm] {analogModbusData.Alarm}");
}
else if (data is DiscreteModbusData discreteModbusData)
{
sb.AppendLine($"Discrete data line: [gid] 0x{gid:X16}, [value] {discreteModbusData.Value}, [alarm] {discreteModbusData.Alarm}");
}
else
{
sb.AppendLine($"UNKNOWN data type: {data.GetType()}");
}
}
Logger.LogDebug(sb.ToString());
}
}
private void GetInegrityUpdateFromScada(ActiveOutageBindingModel outage)
{
using (SCADAIntegrityUpdateProxy proxy = proxyFactory.CreateProxy <SCADAIntegrityUpdateProxy, ISCADAIntegrityUpdateContract>(EndpointNames.SCADAIntegrityUpdateEndpoint))
{
if (proxy == null)
{
string message = "GetInegrityUpdateFromScada => SCADAIntegrityUpdateProxy is null";
Logger.LogError(message);
throw new NullReferenceException(message);
}
SCADAPublication data = proxy.GetIntegrityUpdateForSpecificTopic(Topic.SWITCH_STATUS);
if (data.Message is MultipleDiscreteValueSCADAMessage multipleDiscreteValueSCADAMessage)
{
using (MeasurementMapProxy measurementProxy = proxyFactory.CreateProxy <MeasurementMapProxy, IMeasurementMapContract>(EndpointNames.MeasurementMapEndpoint))
{
if (measurementProxy == null)
{
string errorMessage = "Notify => MeasurementMapProxy is null";
Logger.LogError(errorMessage);
throw new NullReferenceException(errorMessage);
}
Dictionary <long, List <long> > elemetnToMeasurementMap = measurementProxy.GetElementToMeasurementMap();
//UPDATE
foreach (long optimumIsolationPointElementId in outage.OptimumIsolationPoints.Select(p => p.GID))
{
if (!elemetnToMeasurementMap.ContainsKey(optimumIsolationPointElementId))
{
continue;
}
List <long> optimumIsolationPointMeasurementIds = elemetnToMeasurementMap[optimumIsolationPointElementId];
foreach (long optimumIsolationPointMeasurementId in optimumIsolationPointMeasurementIds)
{
if (multipleDiscreteValueSCADAMessage.Data.ContainsKey(optimumIsolationPointMeasurementId))
{
if (!optimumIsolationPointsModbusData.ContainsKey(optimumIsolationPointMeasurementId))
{
optimumIsolationPointsModbusData.Add(optimumIsolationPointMeasurementId, multipleDiscreteValueSCADAMessage.Data[optimumIsolationPointMeasurementId]);
}
}
}
}
foreach (long defaultIsolationPointElementId in outage.DefaultIsolationPoints.Select(p => p.GID))
{
if (!elemetnToMeasurementMap.ContainsKey(defaultIsolationPointElementId))
{
continue;
}
List <long> defaultIsolationPointMeasurementIds = elemetnToMeasurementMap[defaultIsolationPointElementId];
foreach (long defaultIsolationPointMeasuremetId in defaultIsolationPointMeasurementIds)
{
if (multipleDiscreteValueSCADAMessage.Data.ContainsKey(defaultIsolationPointMeasuremetId))
{
if (!defaultIsolationPointsModbusData.ContainsKey(defaultIsolationPointMeasuremetId))
{
defaultIsolationPointsModbusData.Add(defaultIsolationPointMeasuremetId, multipleDiscreteValueSCADAMessage.Data[defaultIsolationPointMeasuremetId]);
}
}
}
if (outage.DefaultToOptimumIsolationPointMap.ContainsKey(defaultIsolationPointElementId))
{
long optimumIsolationPointElementId = outage.DefaultToOptimumIsolationPointMap[defaultIsolationPointElementId];
if (elemetnToMeasurementMap.ContainsKey(optimumIsolationPointElementId))
{
long optimumIsolationPointMeasurementGid = elemetnToMeasurementMap[outage.DefaultToOptimumIsolationPointMap[defaultIsolationPointElementId]].First(); //TODO: ko voli nek izvoli
long defaultIsolationPointMeasurementGid = defaultIsolationPointMeasurementIds.First(); //TODO: ko voli nek izvoli
if (!defaultToOptimumIsolationPointMap.ContainsKey(defaultIsolationPointMeasurementGid))
{
defaultToOptimumIsolationPointMap.Add(defaultIsolationPointMeasurementGid, optimumIsolationPointMeasurementGid);
}
}
}
}
//COMMAND OPEN IF TRUE
Dictionary <long, DiscreteModbusData> defaultIsolationPointsToBeOpened = new Dictionary <long, DiscreteModbusData>();
foreach (long gid in defaultIsolationPointsModbusData.Keys)
{
if (defaultToOptimumIsolationPointMap.ContainsKey(gid))
{
long optimumPointGid = defaultToOptimumIsolationPointMap[gid];
if (optimumIsolationPointsModbusData.ContainsKey(optimumPointGid))
{
ushort optimumIsolationPointValue = optimumIsolationPointsModbusData[optimumPointGid].Value;
if (optimumIsolationPointValue == (ushort)DiscreteCommandingType.CLOSE)
{
defaultIsolationPointsToBeOpened.Add(gid, defaultIsolationPointsModbusData[gid]);
}
}
}
}
OpenIsolationPoints(defaultIsolationPointsToBeOpened);
}
}
else
{
string message = "SCADA returned wrong value for in SCADAPublication. MultipleDiscreteValueSCADAMessage excepted.";
throw new Exception(message);
}
}
}
public SCADAPublication GetIntegrityUpdateForSpecificTopic(Topic topic)
{
if (IntegrityUpdateService.scadaModel == null)
{
string message = $"GetIntegrityUpdate => SCADA model is null.";
Logger.LogError(message);
throw new InternalSCADAServiceException(message);
}
SCADAPublication scadaPublication;
var currentScadaModel = IntegrityUpdateService.scadaModel.CurrentScadaModel;
var commandValuesCache = IntegrityUpdateService.scadaModel.CommandedValuesCache;
Dictionary<long, AnalogModbusData> analogModbusData = new Dictionary<long, AnalogModbusData>();
Dictionary<long, DiscreteModbusData> discreteModbusData = new Dictionary<long, DiscreteModbusData>();
foreach (long gid in currentScadaModel.Keys)
{
CommandOriginType commandOrigin = CommandOriginType.OTHER_COMMAND;
if (topic == Topic.MEASUREMENT && currentScadaModel[gid] is AnalogSCADAModelPointItem analogPointItem)
{
if (commandValuesCache.ContainsKey(gid) && commandValuesCache[gid].Value == analogPointItem.CurrentRawValue)
{
commandOrigin = commandValuesCache[gid].CommandOrigin;
}
AnalogModbusData analogValue = new AnalogModbusData(analogPointItem.CurrentEguValue, analogPointItem.Alarm, gid, commandOrigin);
analogModbusData.Add(gid, analogValue);
}
else if (topic == Topic.SWITCH_STATUS && currentScadaModel[gid] is DiscreteSCADAModelPointItem discretePointItem)
{
if (commandValuesCache.ContainsKey(gid) && commandValuesCache[gid].Value == discretePointItem.CurrentValue)
{
commandOrigin = commandValuesCache[gid].CommandOrigin;
}
DiscreteModbusData discreteValue = new DiscreteModbusData(discretePointItem.CurrentValue, discretePointItem.Alarm, gid, commandOrigin);
discreteModbusData.Add(gid, discreteValue);
}
}
if(topic == Topic.MEASUREMENT)
{
MultipleAnalogValueSCADAMessage analogValuesMessage = new MultipleAnalogValueSCADAMessage(analogModbusData);
scadaPublication = new SCADAPublication(Topic.MEASUREMENT, analogValuesMessage);
}
else if(topic == Topic.SWITCH_STATUS)
{
MultipleDiscreteValueSCADAMessage discreteValuesMessage = new MultipleDiscreteValueSCADAMessage(discreteModbusData);
scadaPublication = new SCADAPublication(Topic.SWITCH_STATUS, discreteValuesMessage);
}
else
{
string message = $"GetIntegrityUpdate => argument topic is neither Topic.MEASUREMENT nor Topic.SWITCH_STATUS.";
Logger.LogError(message);
throw new ArgumentException(message);
}
return scadaPublication;
}
