static void Main(string[] args)
{
ProxyFactory proxyFactory = new ProxyFactory();
long elementGid;
do
{
Console.WriteLine("Enter element gid:");
if (long.TryParse(Console.ReadLine(), out elementGid))
{
using (MeasurementMapProxy proxy = proxyFactory.CreateProxy <MeasurementMapProxy, IMeasurementMapContract>(EndpointNames.MeasurementMapEndpoint))
{
var measurements = proxy.GetMeasurementsOfElement(elementGid);
if (measurements.Count > 0)
{
foreach (long measurementId in measurements)
{
Console.WriteLine($"Masurement gid {measurementId}");
}
}
else
{
Console.WriteLine("There is no measurements for element.");
}
}
}
} while (true);
//Subscriber sub = new Subscriber();
//try
//{
// using (var proxy = new TopologyServiceProxy("TopologyServiceEndpoint"))
// {
// var ui = proxy.GetTopology();
// sub.PrintUI(ui);
// }
//}
//catch (Exception ex)
//{
// Console.WriteLine(ex.Message);
//}
//ProxyFactory proxyFactory = new ProxyFactory();
//proxy = proxyFactory.CreatePRoxy<SubscriberProxy, ISubscriber>(new SCADASubscriber(), EndpointNames.SubscriberEndpoint);
//SubscriberProxy subProxy = new SubscriberProxy(sub, EndpointNames.SubscriberEndpoint);
//subProxy.Subscribe(Topic.TOPOLOGY);
//subProxy.Subscribe(Topic.MEASUREMENT);
//Console.ReadLine();
}
private void SendSCADACommand(long currentBreakerId, DiscreteCommandingType discreteCommandingType)
{
long measrement = -1;
using (MeasurementMapProxy measurementMapProxy = proxyFactory.CreateProxy <MeasurementMapProxy, IMeasurementMapContract>(EndpointNames.MeasurementMapEndpoint))
{
List <long> measuremnts = new List <long>();
try
{
measuremnts = measurementMapProxy.GetMeasurementsOfElement(currentBreakerId);
}
catch (Exception e)
{
//Logger.LogError("Error on GetMeasurementsForElement() method", e);
throw e;
}
if (measuremnts.Count > 0)
{
measrement = measuremnts[0];
}
}
if (measrement != -1)
{
if (discreteCommandingType == DiscreteCommandingType.OPEN && !outageModel.commandedElements.Contains(currentBreakerId))
{
//TODO: add at list
outageModel.commandedElements.Add(currentBreakerId);
}
using (SwitchStatusCommandingProxy scadaCommandProxy = proxyFactory.CreateProxy <SwitchStatusCommandingProxy, ISwitchStatusCommandingContract>(EndpointNames.SwitchStatusCommandingEndpoint))
{
try
{
scadaCommandProxy.SendOpenCommand(measrement);
}
catch (Exception e)
{
if (discreteCommandingType == DiscreteCommandingType.OPEN && outageModel.commandedElements.Contains(currentBreakerId))
{
outageModel.commandedElements.Remove(currentBreakerId);
}
throw e;
}
}
}
}
private void SendSCADACommand(long currentBreakerId, DiscreteCommandingType discreteCommandingType)
{
long measrement = -1;
using (MeasurementMapProxy measurementMapProxy = proxyFactory.CreateProxy <MeasurementMapProxy, IMeasurementMapContract>(EndpointNames.MeasurementMapEndpoint))
{
List <long> measuremnts = new List <long>();
try
{
measuremnts = measurementMapProxy.GetMeasurementsOfElement(currentBreakerId);
}
catch (Exception e)
{
//Logger.LogError("Error on GetMeasurementsForElement() method", e);
throw e;
}
if (measuremnts.Count > 0)
{
measrement = measuremnts[0];
}
}
if (measrement != -1)
{
if (discreteCommandingType == DiscreteCommandingType.OPEN && !outageModel.commandedElements.Contains(currentBreakerId))
{
//TODO: add at list
outageModel.commandedElements.Add(currentBreakerId);
}
using (SCADACommandProxy scadaCommandProxy = proxyFactory.CreateProxy <SCADACommandProxy, ISCADACommand>(EndpointNames.SCADACommandService))
{
try
{
bool success = scadaCommandProxy.SendDiscreteCommand(measrement, (ushort)discreteCommandingType, CommandOriginType.ISOLATING_ALGORITHM_COMMAND);
}
catch (Exception e)
{
if (discreteCommandingType == DiscreteCommandingType.OPEN && outageModel.commandedElements.Contains(currentBreakerId))
{
outageModel.commandedElements.Remove(currentBreakerId);
}
throw e;
}
}
}
}
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 bool StartIsolationAlgorthm(OutageEntity outageToIsolate)
{
List <long> defaultIsolationPoints = outageToIsolate.DefaultIsolationPoints.Select(point => point.EquipmentId).ToList();
bool isIsolated;
bool isFirstBreakerRecloser;
if (defaultIsolationPoints.Count > 0 && defaultIsolationPoints.Count < 3)
{
long headBreaker = -1;
long recloser = -1;
try
{
isFirstBreakerRecloser = CheckIfBreakerIsRecloser(defaultIsolationPoints[0]);
//TODO is second recloser (future)
}
catch (Exception e)
{
Logger.LogWarn("Exception on method CheckIfBreakerIsRecloser()", e);
throw e;
}
GetHeadBreakerAndRecloser(defaultIsolationPoints, isFirstBreakerRecloser, ref headBreaker, ref recloser);
if (headBreaker != -1)
{
ModelCode mc = outageModel.modelResourcesDesc.GetModelCodeFromId(headBreaker);
if (mc == ModelCode.BREAKER)
{
long headBreakerMeasurementId, recloserMeasurementId;
using (MeasurementMapProxy measurementMapProxy = proxyFactory.CreateProxy <MeasurementMapProxy, IMeasurementMapContract>(EndpointNames.MeasurementMapEndpoint))
{
try
{
headBreakerMeasurementId = measurementMapProxy.GetMeasurementsOfElement(headBreaker)[0];
if (recloser != -1)
{
recloserMeasurementId = measurementMapProxy.GetMeasurementsOfElement(recloser)[0];
}
else
{
recloserMeasurementId = -1;
}
}
catch (Exception e)
{
Logger.LogError("Error on GetMeasurementsForElement() method.", e);
throw e;
}
}
Logger.LogInfo($"Head breaker id: 0x{headBreaker:X16}, recloser id: 0x{recloser:X16} (-1 if no recloser).");
//ALGORITHM
AutoResetEvent autoResetEvent = new AutoResetEvent(false);
CancelationObject cancelationObject = new CancelationObject()
{
CancelationSignal = false
};
Timer timer = InitalizeAlgorthmTimer(cancelationObject, autoResetEvent);
ScadaNotification scadaNotification = new ScadaNotification("OutageModel_SCADA_Subscriber", new OutageIsolationAlgorithm.OutageIsolationAlgorithmParameters(headBreakerMeasurementId, recloserMeasurementId, autoResetEvent));
SubscriberProxy subscriberProxy = proxyFactory.CreateProxy <SubscriberProxy, ISubscriber>(scadaNotification, EndpointNames.SubscriberEndpoint);
subscriberProxy.Subscribe(Topic.SWITCH_STATUS);
long currentBreakerId = headBreaker;
while (!cancelationObject.CancelationSignal)
{
if (outageModel.TopologyModel.OutageTopology.ContainsKey(currentBreakerId))
{
currentBreakerId = outageModel.GetNextBreaker(currentBreakerId);
Logger.LogDebug($"Next breaker is 0x{currentBreakerId:X16}.");
if (currentBreakerId == -1 || currentBreakerId == recloser)
{
//TODO: planned outage
string message = "End of the feeder, no outage detected.";
Logger.LogWarn(message);
isIsolated = false;
subscriberProxy.Close();
outageModel.commandedElements.Clear();
throw new Exception(message);
}
//TODO: SCADACommand
SendSCADACommand(currentBreakerId, DiscreteCommandingType.OPEN);
SendSCADACommand(headBreaker, DiscreteCommandingType.CLOSE);
timer.Start();
Logger.LogDebug("Timer started.");
autoResetEvent.WaitOne();
if (timer.Enabled)
{
timer.Stop();
Logger.LogDebug("Timer stoped");
SendSCADACommand(currentBreakerId, DiscreteCommandingType.CLOSE);
}
}
}
long nextBreakerId = outageModel.GetNextBreaker(currentBreakerId);
if (currentBreakerId != 0 && currentBreakerId != recloser)
{
outageToIsolate.OptimumIsolationPoints = outageModel.GetEquipmentEntity(new List <long> {
currentBreakerId, nextBreakerId
});
if (!outageModel.TopologyModel.OutageTopology.ContainsKey(nextBreakerId))
{
string message = $"Breaker (next breaker) with id: 0x{nextBreakerId:X16} is not in topology";
Logger.LogError(message);
throw new Exception(message);
}
long outageElement = outageModel.TopologyModel.OutageTopology[nextBreakerId].FirstEnd;
if (!outageModel.TopologyModel.OutageTopology[currentBreakerId].SecondEnd.Contains(outageElement))
{
string message = $"Outage element with gid: 0x{outageElement:X16} is not on a second end of current breaker id";
Logger.LogError(message);
throw new Exception(message);
}
//TODO: SCADA Command
subscriberProxy.Close();
outageModel.optimumIsolationPoints.Add(currentBreakerId);
outageModel.optimumIsolationPoints.Add(nextBreakerId);
SendSCADACommand(currentBreakerId, DiscreteCommandingType.OPEN);
SendSCADACommand(nextBreakerId, DiscreteCommandingType.OPEN);
outageToIsolate.IsolatedTime = DateTime.UtcNow;
outageToIsolate.OutageElementGid = outageElement;
outageToIsolate.OutageState = OutageState.ISOLATED;
Logger.LogInfo($"Isolation of outage with id {outageToIsolate.OutageId}. Optimum isolation points: 0x{currentBreakerId:X16} and 0x{nextBreakerId:X16}, and outage element id is 0x{outageElement:X16}");
isIsolated = true;
}
else
{
string message = "End of the feeder, no outage detected.";
Logger.LogWarn(message);
isIsolated = false;
subscriberProxy.Close();
outageModel.commandedElements.Clear();
throw new Exception(message);
}
}
else
{
Logger.LogWarn($"Head breaker type is {mc}, not a {ModelCode.BREAKER}.");
isIsolated = false;
}
}
else
{
Logger.LogWarn("Head breaker not found.");
isIsolated = false;
}
}
else
{
Logger.LogWarn($"Number of defaultIsolationPoints ({defaultIsolationPoints.Count}) is out of range [1, 2].");
isIsolated = false;
}
outageModel.commandedElements.Clear();
return(isIsolated);
}
