public override void SetProperty(Property property)
{
switch (property.Id)
{
case ModelCode.BINTERVALSCHEDULE_STARTTIME:
startTime = property.AsDateTime();
break;
case ModelCode.BINTERVALSCHEDULE_V1MULTIPLIER:
v1Multiplier = (UnitMultiplier)property.AsEnum();
break;
case ModelCode.BINTERVALSCHEDULE_V1UNIT:
v1Unit = (UnitSymbol)property.AsEnum();
break;
case ModelCode.BINTERVALSCHEDULE_V2MULTIPLIER:
v2Multiplier = (UnitMultiplier)property.AsEnum();
break;
case ModelCode.BINTERVALSCHEDULE_V2UNIT:
v2Unit = (UnitSymbol)property.AsEnum();
break;
default:
base.SetProperty(property);
break;
}
}
public override void SetProperty(Property property)
{
switch (property.Id)
{
case ModelCode.BASICINTERVALSCHEDULE_STARTTIME:
StartTime = property.AsDateTime();
break;
case ModelCode.BASICINTERVALSCHEDULE_VALUE1MULTIPLIER:
Value1Multiplier = (UnitMultiplier)property.AsEnum();
break;
case ModelCode.BASICINTERVALSCHEDULE_VALUE1UNIT:
Value1Unit = (UnitSymbol)property.AsEnum();
break;
case ModelCode.BASICINTERVALSCHEDULE_VALUE2MULTIPLIER:
Value2Multiplier = (UnitMultiplier)property.AsEnum();
break;
case ModelCode.BASICINTERVALSCHEDULE_VALUE2UNIT:
Value2Unit = (UnitSymbol)property.AsEnum();
break;
default:
base.SetProperty(property);
break;
}
}
public override void SetProperty(Property property)
{
switch (property.Id)
{
case ModelCode.MEASUREMENT_TYPE:
measurementType = property.AsString();
break;
case ModelCode.MEASUREMENT_UNITSYMB:
unitSymbol = (UnitSymbol)property.AsEnum();
break;
case ModelCode.MEASUREMENT_DIRECTION:
direction = (DirectionType)property.AsEnum();
break;
case ModelCode.MEASUREMENT_PSR:
PowerSystemResource = property.AsReference();
break;
default:
base.SetProperty(property);
break;
}
}
// bool da bude, void
public static Tuple <float, float> GetMinMaxRangeForUnit(ProcessVariable pv, UnitSymbol uSymb)
{
Tuple <float, float> range = new Tuple <float, float>(float.MinValue, float.MaxValue);
return(range);
}
public static Tuple <float, float> GetAlarmRange(ProcessVariable pv, UnitSymbol uSymb)
{
Tuple <float, float> range = new Tuple <float, float>(float.MinValue, float.MaxValue);
// to do
return(range);
}
public List <ResourceDescription> MappResult(Response response)
{
List <ResourceDescription> retVal = new List <ResourceDescription>();
ResourceDescription rd;
if (response != null)
{
foreach (ResponseVariable rv in response.Variables)
{
rd = new ResourceDescription();
rd.AddProperty(new Property(ModelCode.IDOBJ_MRID, rv.Id));
switch (rv.VariableType)
{
case ResponseVarType.Analog:
AnalogVariable av = rv as AnalogVariable;
UnitSymbol unitSymbolValue = UnitSymbol.none;
try
{
unitSymbolValue = (UnitSymbol)Enum.Parse(typeof(UnitSymbol), av.UnitSymbol, true);
}
catch (Exception e)
{
//throw;
}
Console.WriteLine("Variable = {0}, Value = {1}, Unit={2}", av.Id, av.Value, av.UnitSymbol.ToString());
rd.AddProperty(new Property(ModelCode.ANALOG_NORMVAL, av.Value));
break;
case ResponseVarType.Digital:
DigitalVariable dv = rv as DigitalVariable;
Console.WriteLine("Variable = {0}, STATE = {1}", dv.Id, dv.State);
if (dv.State.ToString() == "CLOSED")
{
rd.AddProperty(new Property(ModelCode.DISCRETE_NORMVAL, 0));
}
else
{
rd.AddProperty(new Property(ModelCode.DISCRETE_NORMVAL, 1));
}
break;
case ResponseVarType.Counter:
break;
}
retVal.Add(rd);
}
}
return(retVal);
}
public void CanDeclareClassifier()
{
var interpreter = new LineInterpreter();
interpreter.ParseAndExecute("glob is I");
interpreter.ParseAndExecute("glob glob Silver is 34 Credits");
var silverSymbol = new ClassifierSymbol("Silver");
var creditsSymbol = new UnitSymbol("Credits");
Assert.IsTrue(interpreter.Processor.ClassifiersTable.ContainsKey(silverSymbol));
Assert.IsTrue(interpreter.Processor.ClassifiersTable[silverSymbol].Contains(creditsSymbol));
Assert.AreEqual(17, interpreter.Processor.ClassifiersTable[silverSymbol].Find(s => s.Equals(creditsSymbol)).Factor);
}
public override void SetProperty(Property property)
{
switch (property.Id)
{
case ModelCode.CURVE_STYLE:
curveStyle = (CurveStyle)property.AsEnum();
break;
case ModelCode.CURVE_XMULTPLIER:
xMultiplier = (UnitMultiplier)property.AsEnum();
break;
case ModelCode.CURVE_XUNIT:
xUnit = (UnitSymbol)property.AsEnum();
break;
case ModelCode.CURVE_Y1MULTIPLIER:
y1Multiplier = (UnitMultiplier)property.AsEnum();
break;
case ModelCode.CURVE_Y1UNIT:
y1Unit = (UnitSymbol)property.AsEnum();
break;
case ModelCode.CURVE_Y2MULTIPLIER:
y2Multiplier = (UnitMultiplier)property.AsEnum();
break;
case ModelCode.CURVE_Y2UNIT:
y2Unit = (UnitSymbol)property.AsEnum();
break;
case ModelCode.CURVE_Y3MULTIPLIER:
y3Multiplier = (UnitMultiplier)property.AsEnum();
break;
case ModelCode.CURVE_Y3UNIT:
y3Unit = (UnitSymbol)property.AsEnum();
break;
default:
base.SetProperty(property);
break;
}
}
public override void SetProperty(Property property)
{
switch (property.Id)
{
case ModelCode.BIS_STARTTIME:
startTime = property.AsLong();
break;
case ModelCode.BIS_VAL1UNIT:
value1Unit = (UnitSymbol)property.AsEnum();
break;
default:
base.SetProperty(property);
break;
}
}
public bool DeserializeScadaModel(string deserializationSource = "ScadaModel.xml")
{
// to do
Database.IsConfigurationFinished = false;
string message = string.Empty;
string configurationName = deserializationSource;
string source = Path.Combine(basePath, configurationName);
if (Database.Instance.RTUs.Count != 0)
{
Database.Instance.RTUs.Clear();
}
if (Database.Instance.ProcessVariablesName.Count != 0)
{
Database.Instance.ProcessVariablesName.Clear();
}
try
{
XElement xdocument = XElement.Load(source);
// access RTUS, DIGITALS, ANALOGS, COUNTERS from ScadaModel root
IEnumerable <XElement> elements = xdocument.Elements();
var rtus = xdocument.Element("RTUS").Elements("RTU").ToList();
var digitals = (from dig in xdocument.Element("Digitals").Elements("Digital")
orderby(int) dig.Element("RelativeAddress")
select dig).ToList();
var analogs = (from dig in xdocument.Element("Analogs").Elements("Analog")
orderby(int) dig.Element("RelativeAddress")
select dig).ToList();
var counters = (from dig in xdocument.Element("Counters").Elements("Counter")
orderby(int) dig.Element("RelativeAddress")
select dig).ToList();
// parsing RTUS
if (rtus.Count != 0)
{
foreach (var rtu in rtus)
{
RTU newRtu;
string uniqueName = (string)rtu.Element("Name");
// if RTU with that name does not already exist?
if (!dbContext.Database.RTUs.ContainsKey(uniqueName))
{
byte address = (byte)(int)rtu.Element("Address");
bool freeSpaceForDigitals = (bool)rtu.Element("FreeSpaceForDigitals");
bool freeSpaceForAnalogs = (bool)rtu.Element("FreeSpaceForAnalogs");
string stringProtocol = (string)rtu.Element("Protocol");
IndustryProtocols protocol = (IndustryProtocols)Enum.Parse(typeof(IndustryProtocols), stringProtocol);
int digOutStartAddr = (int)rtu.Element("DigOutStartAddr");
int digInStartAddr = (int)rtu.Element("DigInStartAddr");
int anaInStartAddr = (int)rtu.Element("AnaInStartAddr");
int anaOutStartAddr = (int)rtu.Element("AnaOutStartAddr");
int counterStartAddr = (int)rtu.Element("CounterStartAddr");
int digOutCount = (int)rtu.Element("NoDigOut");
int digInCount = (int)rtu.Element("NoDigIn");
int anaInCount = (int)rtu.Element("NoAnaIn");
int anaOutCount = (int)rtu.Element("NoAnaOut");
int counterCount = (int)rtu.Element("NoCnt");
ushort anaInRawMin = (ushort)(int)rtu.Element("AnaInRawMin");
ushort anaInRawMax = (ushort)(int)rtu.Element("AnaInRawMax");
ushort anaOutRawMin = (ushort)(int)rtu.Element("AnaOutRawMin");
ushort anaOutRawMax = (ushort)(int)rtu.Element("AnaOutRawMax");
if (digOutCount != digInCount)
{
message = string.Format("Invalid config: RTU - {0}: Value of DigOutCount must be the same as Value of DigInCount", uniqueName);
Console.WriteLine(message);
return(false);
}
newRtu = new RTU()
{
Name = uniqueName,
Address = address,
FreeSpaceForDigitals = freeSpaceForDigitals,
FreeSpaceForAnalogs = freeSpaceForAnalogs,
Protocol = protocol,
DigOutStartAddr = digOutStartAddr,
DigInStartAddr = digInStartAddr,
AnaInStartAddr = anaInStartAddr,
AnaOutStartAddr = anaOutStartAddr,
CounterStartAddr = counterStartAddr,
NoDigOut = digOutCount,
NoDigIn = digInCount,
NoAnaIn = anaInCount,
NoAnaOut = anaOutCount,
NoCnt = counterCount,
AnaInRawMin = anaInRawMin,
AnaInRawMax = anaInRawMax,
AnaOutRawMin = anaOutRawMin,
AnaOutRawMax = anaOutRawMax
};
dbContext.AddRTU(newRtu);
}
else
{
// to do: bacati exception mozda
message = string.Format("Invalid config: There is multiple RTUs with Name={0}!", uniqueName);
Console.WriteLine(message);
return(false);
}
}
}
else
{
message = string.Format("Invalid config: file must contain at least 1 RTU!");
Console.WriteLine(message);
return(false);
}
//parsing DIGITALS. ORDER OF RELATIVE ADDRESSES IS IMPORTANT
if (digitals.Count != 0)
{
foreach (var d in digitals)
{
string procContr = (string)d.Element("ProcContrName");
// does RTU exists?
RTU associatedRtu;
if ((associatedRtu = dbContext.GetRTUByName(procContr)) != null)
{
Digital newDigital = new Digital();
// SETTING ProcContrName
newDigital.ProcContrName = procContr;
string uniqueName = (string)d.Element("Name");
// variable with that name does not exists in db?
if (!dbContext.Database.ProcessVariablesName.ContainsKey(uniqueName))
{
// SETTING Name
newDigital.Name = uniqueName;
// SETTING State
string stringCurrentState = (string)d.Element("State");
States stateValue = (States)Enum.Parse(typeof(States), stringCurrentState);
newDigital.State = stateValue;
// SETTING Command parameter - for initializing Simulator with last command
string lastCommandString = (string)d.Element("Command");
CommandTypes command = (CommandTypes)Enum.Parse(typeof(CommandTypes), lastCommandString);
// SETTING Class
string digDevClass = (string)d.Element("Class");
DigitalDeviceClasses devClass = (DigitalDeviceClasses)Enum.Parse(typeof(DigitalDeviceClasses), digDevClass);
newDigital.Class = devClass;
// SETTING RelativeAddress
ushort relativeAddress = (ushort)(int)d.Element("RelativeAddress");
newDigital.RelativeAddress = relativeAddress;
var hasCommands = d.Element("ValidCommands");
if (hasCommands.HasElements)
{
var validCommands = hasCommands.Elements("Command").ToList();
// SETTING ValidCommands
foreach (var xElementCommand in validCommands)
{
string stringCommand = (string)xElementCommand;
CommandTypes validCommand = (CommandTypes)Enum.Parse(typeof(CommandTypes), stringCommand);
newDigital.ValidCommands.Add(validCommand);
}
}
else
{
message = string.Format("Invalid config: Variable = {0} does not contain commands.", uniqueName);
Console.WriteLine(message);
return(false);
}
var hasStates = d.Element("ValidStates");
if (hasStates.HasElements)
{
var validStates = hasStates.Elements("State").ToList();
// SETTING ValidStates
foreach (var xElementState in validStates)
{
string stringState = (string)xElementState;
States state = (States)Enum.Parse(typeof(States), stringState);
newDigital.ValidStates.Add(state);
}
}
else
{
message = string.Format("Invalid config: Variable = {0} does not contain states.", uniqueName);
Console.WriteLine(message);
return(false);
}
ushort calculatedRelativeAddres;
if (associatedRtu.TryMap(newDigital, out calculatedRelativeAddres))
{
if (relativeAddress == calculatedRelativeAddres)
{
if (associatedRtu.MapProcessVariable(newDigital))
{
dbContext.AddProcessVariable(newDigital);
}
}
else
{
message = string.Format("Invalid config: Variable = {0} RelativeAddress = {1} is not valid.", uniqueName, relativeAddress);
Console.WriteLine(message);
return(false);
}
}
}
else
{
message = string.Format("Invalid config: Name = {0} is not unique. Variable already exists", uniqueName);
Console.WriteLine(message);
return(false);
}
}
else
{
message = string.Format("Invalid config: Parsing Digitals, ProcContrName = {0} does not exists.", procContr);
Console.WriteLine(message);
return(false);
}
}
}
// parsing ANALOGS. ORDER OF RELATIVE ADDRESSES IS IMPORTANT
if (analogs.Count != 0)
{
foreach (var a in analogs)
{
string procContr = (string)a.Element("ProcContrName");
// does RTU exists?
RTU associatedRtu;
if ((associatedRtu = dbContext.GetRTUByName(procContr)) != null)
{
Analog newAnalog = new Analog();
// SETTING ProcContrName
newAnalog.ProcContrName = procContr;
string uniqueName = (string)a.Element("Name");
// variable with that name does not exists in db?
if (!dbContext.Database.ProcessVariablesName.ContainsKey(uniqueName))
{
// SETTING Name
newAnalog.Name = uniqueName;
// SETTING NumOfRegisters
ushort numOfReg = (ushort)(int)a.Element("NumOfRegisters");
newAnalog.NumOfRegisters = numOfReg;
// SETTING AcqValue
ushort acqValue = (ushort)(float)a.Element("AcqValue");
newAnalog.AcqValue = acqValue;
// SETTING CommValue
ushort commValue = (ushort)(float)a.Element("CommValue");
newAnalog.CommValue = commValue;
// SETTING MinValue
float minValue = (float)a.Element("MinValue");
newAnalog.MinValue = minValue;
// SETTING MaxValue
float maxValue = (float)a.Element("MaxValue");
newAnalog.MaxValue = maxValue;
// SETTING UnitSymbol
string stringUnitSymbol = (string)a.Element("UnitSymbol");
UnitSymbol unitSymbolValue = (UnitSymbol)Enum.Parse(typeof(UnitSymbol), stringUnitSymbol, true);
newAnalog.UnitSymbol = unitSymbolValue;
// SETTING RelativeAddress
ushort relativeAddress = (ushort)(int)a.Element("RelativeAddress");
newAnalog.RelativeAddress = relativeAddress;
// svejedno je uzeli AnaInRawMin ili AnaOutRawMin -> isti su trenutni,
// sve dok imamo samo Analog.cs a ne AnaIn.cs + AnaOut.cs (dok je kao za digital)
newAnalog.RawBandLow = associatedRtu.AnaInRawMin;
newAnalog.RawBandHigh = associatedRtu.AnaInRawMax;
// SETTING RawAcqValue and RawCommValue
AnalogProcessor.EGUToRawValue(newAnalog);
ushort calculatedRelativeAddres;
if (associatedRtu.TryMap(newAnalog, out calculatedRelativeAddres))
{
if (relativeAddress == calculatedRelativeAddres)
{
if (associatedRtu.MapProcessVariable(newAnalog))
{
dbContext.AddProcessVariable(newAnalog);
}
}
else
{
message = string.Format("Invalid config: Analog Variable = {0} RelativeAddress = {1} is not valid.", uniqueName, relativeAddress);
Console.WriteLine(message);
return(false);
}
}
}
else
{
message = string.Format("Invalid config: Name = {0} is not unique. Analog Variable already exists", uniqueName);
Console.WriteLine(message);
return(false);
}
}
else
{
message = string.Format("Invalid config: Parsing Analogs, ProcContrName = {0} does not exists.", procContr);
Console.WriteLine(message);
return(false);
}
}
}
// to do:
if (counters.Count != 0)
{
}
Console.WriteLine("Configuration passed successfully.");
}
catch (FileNotFoundException e)
{
Console.WriteLine(e.Message);
return(false);
}
catch (XmlException e)
{
Console.WriteLine(e.Message);
return(false);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
return(false);
}
Database.IsConfigurationFinished = true;
return(true);
}
/* possible scenarios:
*
* 1. there is a .data file on DMS, NMS, and there is nothing in ScadaModel.xml part for ProcessVariables (e.g. empty <digitals> tag...)
* -> everything is ok, just apply delta again regularly...
*
* 2. there is no .data file on DMS, NMS, and there IS data in ScadaModel.xml part
* -> PROBLEM: ako npr. dodamo 3 prekidaca, a sa strane skade ta tri vec postoje, to treba posmatrati kao UPDATE!
* znaci iako je u insert operaciji jer u ostatku sistema ne postoji (nema .data),
* zapravo je update jer na skadi postoji...
*/
public bool ApplyDelta(ScadaDelta delta)
{
bool retVal = false;
/*
* prvo proveriti prirodu delte:
* da li radimo SAMO UPDATE,
* ili I INSERT i UPDATE,
* ili samo INSERT
*
* 1. ako nije <samo update> proveri da li uopste imas mesta za one koji su insert, ako nema return false (rejecting whole delta)
* 2. ako ima mesta za insert pronadji elemente koji su za update, izvadi ih u zasebnu listu i prvo njih radi, a ostatak radi insert
*/
List <ScadaElement> updateOperations = delta.UpdateOps;
// to do: objasniti ovo
// this list acutally can contains update operations also. case 2. above descripted
// we have to segregate treal update from insert...
List <ScadaElement> deltaOperations = delta.InsertOps;
List <ScadaElement> realInsertOperatins = new List <ScadaElement>();
List <ScadaElement> realUpdateOperatins = new List <ScadaElement>();
if (updateOperations.Count != 0)
{
realUpdateOperatins = updateOperations;
}
bool isOnlyUpdate = true;
foreach (var el in deltaOperations)
{
// if only one element from scadaDelta DOES NOT already exist in db, it means it is for inserting
var pvs = Database.ProcessVariablesName;
if (!pvs.ContainsKey(el.Name))
{
// we have some elements for insert
isOnlyUpdate = false;
break;
}
}
List <RTU> availableRtus = null;
// temporary storage for elements for adding. key is RTU name, value is PVs mapped to that RTU
Dictionary <string, List <ProcessVariable> > rtuElementsMap = null;
// we have some elements in deltaOperatins for insert
if (!isOnlyUpdate)
{
availableRtus = new List <RTU>();
availableRtus = GettAllRTUs().Values.Where(r => r.FreeSpaceForDigitals == true ||
r.FreeSpaceForAnalogs == true).ToList();
// there is no space for inserting in any RTU, rejecting whole delta
if (availableRtus.Count == 0)
{
Console.WriteLine("There is no available RTUs for inserting.");
return(false);
}
else
{
// init
rtuElementsMap = new Dictionary <string, List <ProcessVariable> >();
foreach (var ar in availableRtus)
{
rtuElementsMap.Add(ar.Name, new List <ProcessVariable>());
}
// separating elements for update from elements for insert
var pvs = Database.ProcessVariablesName;
foreach (var el in deltaOperations)
{
if (!pvs.ContainsKey(el.Name))
{
realInsertOperatins.Add(el);
}
else
{
realUpdateOperatins.Add(el);
}
}
// this list is not necessary anymore
deltaOperations.Clear();
}
}
else
{
// whole list deltaOperations is actually for update
realUpdateOperatins = deltaOperations;
}
// to do:
// processing real updates - ZA SADA SAMO TRUE VRACA!!! i odmah breakuje
foreach (var updateEl in realUpdateOperatins)
{
// TO DO: nekad u buducnosti....
// napraviti metodu. da proverava da li su objekti isti? (novi i ovaj koji se dodaje) i koji propertiji nisu...ako
// u sustini treba porediti samo stanja, komande, i trenutno stanje komandu; a za analog novu comm value sa trenutnom u deviceu
// i onda se proveri ako postoji na kom je rtu-u i update-uje se.
//https://stackoverflow.com/questions/2901289/updating-fields-of-values-in-a-concurrentdictionary
//https://stackoverflow.com/questions/41592129/updating-list-in-concurrentdictionary
Console.WriteLine("Variable Name = {0} is successfully updated.", updateEl.Name);
retVal = true;
break;
}
// processing real insertions
int possibleInsertionsCount = 0;
foreach (var insertEl in realInsertOperatins)
{
bool isInsertingPossible = false;
ProcessVariable pv;
if (!GetProcessVariableByName(insertEl.Name, out pv))
{
switch (insertEl.Type)
{
case DeviceTypes.DIGITAL:
if (insertEl.ValidCommands.Count != insertEl.ValidStates.Count)
{
Console.WriteLine("Element Name = {0} -> ValidCommands.Count!=ValidStates.Count", insertEl.Name);
break;
}
Digital newDigital = new Digital()
{
Name = insertEl.Name,
ValidCommands = insertEl.ValidCommands,
ValidStates = insertEl.ValidStates
};
// pokusaj da nadjes mesta za tu varijablu u bilo kom RTUu
// nekad u buducnosti tu se moze neki lep algoritam narpaviti, optimizovati :)
foreach (var availableRtu in availableRtus)
{
// there is no channel with RTU-2 currently
// test this case sometime in the future xD
if (availableRtu.Name == "RTU-2")
{
continue;
}
ushort relativeAddress;
// kljucno! check if is possible mapping in this rtu
if (availableRtu.TryMap(newDigital, out relativeAddress))
{
newDigital.RelativeAddress = relativeAddress;
// mapiranje se vrsi u metodi addProcessVariable kasnije,
// preko relativne adrese upravo dodeljene
// Od ovog trenutka se podrazumeva da ce dodavanje uspeti!
// brojac mapiranih adresa u RTUu je nepovratno promenjen...
// ako nesto crkne posle, u rollbacku vracamo na staru konfiguraciju citanjem iz fajla
// mozda nije bas najveselije resenje za sada xD
newDigital.ProcContrName = availableRtu.Name;
// podrazumevamo da insertujemo prekidac u dozvoljenom - zeljenom stanju
newDigital.State = States.CLOSED;
newDigital.Command = CommandTypes.CLOSE;
var elements = rtuElementsMap[availableRtu.Name];
elements.Add(newDigital);
possibleInsertionsCount++;
isInsertingPossible = true;
break; // it is possible to insert element
}
}
break;
case DeviceTypes.ANALOG:
// to do:
// provera da li je nova vrednost u dozvoljenom rangeu
Analog newAnalog = new Analog()
{
Name = insertEl.Name
};
foreach (var availableRtu in availableRtus)
{
// there is no channel with RTU-2 currently
if (availableRtu.Name == "RTU-2")
{
continue;
}
ushort relativeAddress;
// if is possible mapping in this rtu?
if (availableRtu.TryMap(newAnalog, out relativeAddress))
{
newAnalog.RelativeAddress = relativeAddress;
// Od ovog trenutka se podrazumeva da ce dodavanje uspeti!
newAnalog.ProcContrName = availableRtu.Name;
newAnalog.AcqValue = insertEl.WorkPoint;
newAnalog.CommValue = insertEl.WorkPoint;
newAnalog.RawBandLow = availableRtu.AnaInRawMin;
newAnalog.RawBandHigh = availableRtu.AnaInRawMax;
string unitSimString = insertEl.UnitSymbol;
UnitSymbol unitSym = (UnitSymbol)Enum.Parse(typeof(UnitSymbol), unitSimString, true);
var elements = rtuElementsMap[availableRtu.Name];
elements.Add(newAnalog);
possibleInsertionsCount++;
isInsertingPossible = true;
break; // it is possible to insert element
}
}
break;
default:
// all other - not supported yet, will return false
break;
}
}
else
{
Console.WriteLine("ozbiljan error, variabla ne postoji! nije smelo false da se desi :D");
}
// if we encounter ProcessVarible that can not be inserted, dont process the rest -> reject whole delta
if (!isInsertingPossible)
{
break;
}
}
// if we have insertions, and only if it is possible to insert all, otherwise nothing
if (realInsertOperatins.Count != 0 && possibleInsertionsCount == realInsertOperatins.Count)
{
int addedCount = 0;
foreach (var rtuElements in rtuElementsMap)
{
var availableRtu = GetRTUByName(rtuElements.Key);
var elements = rtuElementsMap[rtuElements.Key];
foreach (var elForAdd in elements)
{
if (availableRtu.MapProcessVariable(elForAdd))
{
AddProcessVariable(elForAdd);
addedCount++;
// if is an analog, SEND COMMAND to init sim
}
}
}
if (addedCount == realInsertOperatins.Count)
{
retVal = true;
}
}
else
{
// problem -> mappingDig je promenjen nepovratno u tryMap, i Bog zna u kojim sve RTUovima. znaci radi se opet
// deserijalizacija ako je false ovde. ovde se radi deserijalizacija iz onog konfig fajla osnovnog
}
return(retVal);
}
public override object ConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, System.Type destinationType)
{
if ((value == null))
{
return(null);
}
UnitSymbol valueCasted = ((UnitSymbol)(value));
if ((valueCasted == UnitSymbol.A))
{
return("A");
}
if ((valueCasted == UnitSymbol.Rad))
{
return("rad");
}
if ((valueCasted == UnitSymbol.None))
{
return("none");
}
if ((valueCasted == UnitSymbol.V))
{
return("V");
}
if ((valueCasted == UnitSymbol.G))
{
return("g");
}
if ((valueCasted == UnitSymbol.WHz))
{
return("WHz");
}
if ((valueCasted == UnitSymbol.M2))
{
return("m2");
}
if ((valueCasted == UnitSymbol.VA))
{
return("VA");
}
if ((valueCasted == UnitSymbol.VArh))
{
return("VArh");
}
if ((valueCasted == UnitSymbol.N))
{
return("N");
}
if ((valueCasted == UnitSymbol.Pa))
{
return("Pa");
}
if ((valueCasted == UnitSymbol.VAh))
{
return("VAh");
}
if ((valueCasted == UnitSymbol.F))
{
return("F");
}
if ((valueCasted == UnitSymbol.H))
{
return("H");
}
if ((valueCasted == UnitSymbol.Hzminus1))
{
return("Hzminus1");
}
if ((valueCasted == UnitSymbol.J))
{
return("J");
}
if ((valueCasted == UnitSymbol.Ws))
{
return("Ws");
}
if ((valueCasted == UnitSymbol.M))
{
return("m");
}
if ((valueCasted == UnitSymbol.S))
{
return("S");
}
if ((valueCasted == UnitSymbol.Min))
{
return("min");
}
if ((valueCasted == UnitSymbol.Deg))
{
return("deg");
}
if ((valueCasted == UnitSymbol.Js))
{
return("Js");
}
if ((valueCasted == UnitSymbol.S1))
{
return("s");
}
if ((valueCasted == UnitSymbol.Wh))
{
return("Wh");
}
if ((valueCasted == UnitSymbol.M3))
{
return("m3");
}
if ((valueCasted == UnitSymbol.ºC))
{
return("ºC");
}
if ((valueCasted == UnitSymbol.VVAr))
{
return("VVAr");
}
if ((valueCasted == UnitSymbol.Sminus1))
{
return("sminus1");
}
if ((valueCasted == UnitSymbol.H_))
{
return("h_");
}
if ((valueCasted == UnitSymbol.W))
{
return("W");
}
if ((valueCasted == UnitSymbol.Ohm))
{
return("ohm");
}
if ((valueCasted == UnitSymbol.Hz))
{
return("Hz");
}
if ((valueCasted == UnitSymbol.VAr))
{
return("VAr");
}
if ((valueCasted == UnitSymbol.KgJ))
{
return("kgJ");
}
throw new ArgumentOutOfRangeException("value");
}
public bool DeserializeScadaModel(string deserializationSource = "ScadaModel.xml")
{
// to do
Database.IsConfigurationFinished = false;
string message = string.Empty;
string configurationName = deserializationSource;
// string source = Path.Combine(basePath, configurationName);
if (Database.Instance.RTUs.Count != 0)
{
Database.Instance.RTUs.Clear();
}
if (Database.Instance.ProcessVariablesName.Count != 0)
{
Database.Instance.ProcessVariablesName.Clear();
}
try
{
// XElement xdocument = XElement.Load(source);
// access RTUS, DIGITALS, ANALOGS, COUNTERS from ScadaModel root
// IEnumerable<XElement> elements = xdocument.Elements();
//var rtus = xdocument.Element("RTUS").Elements("RTU").ToList();
//var digitals = (from dig in xdocument.Element("Digitals").Elements("Digital")
// orderby (int)dig.Element("RelativeAddress")
// select dig).ToList();
//var analogs = (from dig in xdocument.Element("Analogs").Elements("Analog")
// orderby (int)dig.Element("RelativeAddress")
// select dig).ToList();
//var counters = (from dig in xdocument.Element("Counters").Elements("Counter")
// orderby (int)dig.Element("RelativeAddress")
// select dig).ToList();
List <ScadaDBClassLib.ModelData.RTU> rtus = new List <ScadaDBClassLib.ModelData.RTU>();
List <ScadaDBClassLib.ModelData.Digital> digitals = new List <ScadaDBClassLib.ModelData.Digital>();
List <ScadaDBClassLib.ModelData.Analog> analogs = new List <ScadaDBClassLib.ModelData.Analog>();
using (ScadaDBClassLib.ScadaCtxcs ctx = new ScadaDBClassLib.ScadaCtxcs())
{
rtus = ctx.RTUs.ToList();
digitals = ctx.Digitals.ToList();
analogs = ctx.Analogs.ToList();
}
// parsing RTUS
if (rtus.Count != 0)
{
foreach (var rtu in rtus)
{
RTU newRtu;
string uniqueName = (string)rtu.Name;
// if RTU with that name does not already exist?
if (!dbContext.Database.RTUs.ContainsKey(uniqueName))
{
byte address = (byte)(int)rtu.Address;
bool freeSpaceForDigitals = (bool)rtu.FreeSpaceForDigitals;
bool freeSpaceForAnalogs = (bool)rtu.FreeSpaceForAnalogs;
IndustryProtocols protocol = IndustryProtocols.ModbusTCP;
int digOutStartAddr = (int)rtu.DigOutStartAddr;
int digInStartAddr = (int)rtu.DigInStartAddr;
int anaInStartAddr = (int)rtu.AnaInStartAddr;
int anaOutStartAddr = (int)rtu.AnaOutStartAddr;
int counterStartAddr = (int)rtu.CounterStartAddr;
int digOutCount = (int)rtu.NoDigOut;
int digInCount = (int)rtu.NoDigIn;
int anaInCount = (int)rtu.NoAnaIn;
int anaOutCount = (int)rtu.NoAnaOut;
int counterCount = (int)rtu.NoCnt;
ushort anaInRawMin = (ushort)(int)rtu.AnaInRawMin;
ushort anaInRawMax = (ushort)(int)rtu.AnaInRawMax;
ushort anaOutRawMin = (ushort)(int)rtu.AnaOutRawMin;
ushort anaOutRawMax = (ushort)(int)rtu.AnaOutRawMax;
if (digOutCount != digInCount)
{
message = string.Format("Invalid config: RTU - {0}: Value of DigOutCount must be the same as Value of DigInCount", uniqueName);
Console.WriteLine(message);
return(false);
}
newRtu = new RTU()
{
Name = uniqueName,
Address = address,
FreeSpaceForDigitals = freeSpaceForDigitals,
FreeSpaceForAnalogs = freeSpaceForAnalogs,
Protocol = protocol,
DigOutStartAddr = digOutStartAddr,
DigInStartAddr = digInStartAddr,
AnaInStartAddr = anaInStartAddr,
AnaOutStartAddr = anaOutStartAddr,
CounterStartAddr = counterStartAddr,
NoDigOut = digOutCount,
NoDigIn = digInCount,
NoAnaIn = anaInCount,
NoAnaOut = anaOutCount,
NoCnt = counterCount,
AnaInRawMin = anaInRawMin,
AnaInRawMax = anaInRawMax,
AnaOutRawMin = anaOutRawMin,
AnaOutRawMax = anaOutRawMax
};
//using (ScadaContextDB ctx = new ScadaContextDB())
//{
// ctx.RTUs.Add(new ScadaCloud.Model.RTU
// {
// Name = uniqueName,
// Address = address,
// FreeSpaceForDigitals = freeSpaceForDigitals,
// FreeSpaceForAnalogs = freeSpaceForAnalogs,
// Protocol = protocol,
// DigOutStartAddr = digOutStartAddr,
// DigInStartAddr = digInStartAddr,
// AnaInStartAddr = anaInStartAddr,
// AnaOutStartAddr = anaOutStartAddr,
// CounterStartAddr = counterStartAddr,
// NoDigOut = digOutCount,
// NoDigIn = digInCount,
// NoAnaIn = anaInCount,
// NoAnaOut = anaOutCount,
// NoCnt = counterCount,
// AnaInRawMin = anaInRawMin,
// AnaInRawMax = anaInRawMax,
// AnaOutRawMin = anaOutRawMin,
// AnaOutRawMax = anaOutRawMax
// });
// ctx.SaveChanges();
//}
dbContext.AddRTU(newRtu);
}
else
{
// to do: bacati exception mozda
message = string.Format("Invalid config: There is multiple RTUs with Name={0}!", uniqueName);
Console.WriteLine(message);
return(false);
}
}
}
else
{
message = string.Format("Invalid config: file must contain at least 1 RTU!");
Console.WriteLine(message);
return(false);
}
//parsing DIGITALS. ORDER OF RELATIVE ADDRESSES IS IMPORTANT
if (digitals.Count != 0)
{
foreach (var d in digitals)
{
string procContr = (string)d.ProcContrName;
// does RTU exists?
RTU associatedRtu;
if ((associatedRtu = dbContext.GetRTUByName(procContr)) != null)
{
Digital newDigital = new Digital();
// SETTING ProcContrName
newDigital.ProcContrName = procContr;
string uniqueName = (string)d.Name;
// variable with that name does not exists in db?
if (!dbContext.Database.ProcessVariablesName.ContainsKey(uniqueName))
{
// SETTING Name
newDigital.Name = uniqueName;
// SETTING State
string stringCurrentState = (string)d.State;
States stateValue = (States)Enum.Parse(typeof(States), stringCurrentState);
newDigital.State = stateValue;
// SETTING Command parameter - for initializing Simulator with last command
string lastCommandString = (string)d.Command;
CommandTypes command = (CommandTypes)Enum.Parse(typeof(CommandTypes), lastCommandString);
// SETTING Class
DigitalDeviceClasses devClass = DigitalDeviceClasses.SWITCH;
newDigital.Class = devClass;
// SETTING RelativeAddress
ushort relativeAddress = (ushort)(int)d.RelativeAddress;
newDigital.RelativeAddress = relativeAddress;
// SETTING ValidCommands
newDigital.ValidCommands.Add(CommandTypes.OPEN);
newDigital.ValidCommands.Add(CommandTypes.CLOSE);
newDigital.ValidStates.Add(States.CLOSED);
newDigital.ValidStates.Add(States.OPENED);
//using (ScadaContextDB ctx = new ScadaContextDB())
//{
// ctx.Digirals.Add(new ScadaCloud.Model.Digital
// {
// Name = uniqueName,
// RelativeAddress = relativeAddress,
// ProcContrName = procContr,
// State = stringCurrentState,
// Command = lastCommandString
// });
// ctx.SaveChanges();
//}
ushort calculatedRelativeAddres;
if (associatedRtu.TryMap(newDigital, out calculatedRelativeAddres))
{
if (relativeAddress == calculatedRelativeAddres)
{
if (associatedRtu.MapProcessVariable(newDigital))
{
dbContext.AddProcessVariable(newDigital);
}
}
else
{
message = string.Format("Invalid config: Variable = {0} RelativeAddress = {1} is not valid.", uniqueName, relativeAddress);
Console.WriteLine(message);
continue;
}
}
}
else
{
message = string.Format("Invalid config: Name = {0} is not unique. Variable already exists", uniqueName);
Console.WriteLine(message);
continue;
}
}
else
{
message = string.Format("Invalid config: Parsing Digitals, ProcContrName = {0} does not exists.", procContr);
Console.WriteLine(message);
return(false);
}
}
}
// parsing ANALOGS. ORDER OF RELATIVE ADDRESSES IS IMPORTANT
if (analogs.Count != 0)
{
foreach (var a in analogs)
{
string procContr = (string)a.ProcContrName;
// does RTU exists?
RTU associatedRtu;
if ((associatedRtu = dbContext.GetRTUByName(procContr)) != null)
{
Analog newAnalog = new Analog();
// SETTING ProcContrName
newAnalog.ProcContrName = procContr;
string uniqueName = (string)a.Name;
// variable with that name does not exists in db?
if (!dbContext.Database.ProcessVariablesName.ContainsKey(uniqueName))
{
// SETTING Name
newAnalog.Name = uniqueName;
// SETTING NumOfRegisters
ushort numOfReg = (ushort)(int)a.NumOfRegisters;
newAnalog.NumOfRegisters = numOfReg;
// SETTING AcqValue
ushort acqValue = (ushort)(float)a.AcqValue;
newAnalog.AcqValue = acqValue;
// SETTING CommValue
ushort commValue = (ushort)(float)a.CommValue;
newAnalog.CommValue = commValue;
// SETTING MinValue
float minValue = (float)a.MinValue;
newAnalog.MinValue = minValue;
// SETTING MaxValue
float maxValue = (float)a.MaxValue;
newAnalog.MaxValue = maxValue;
// SETTING UnitSymbol
string stringUnitSymbol = (string)a.UnitSymbol;
UnitSymbol unitSymbolValue = (UnitSymbol)Enum.Parse(typeof(UnitSymbol), stringUnitSymbol, true);
newAnalog.UnitSymbol = unitSymbolValue;
// SETTING RelativeAddress
ushort relativeAddress = (ushort)(int)a.RelativeAddress;
newAnalog.RelativeAddress = relativeAddress;
// svejedno je uzeli AnaInRawMin ili AnaOutRawMin -> isti su trenutni,
// sve dok imamo samo Analog.cs a ne AnaIn.cs + AnaOut.cs (dok je kao za digital)
newAnalog.RawBandLow = associatedRtu.AnaInRawMin;
newAnalog.RawBandHigh = associatedRtu.AnaInRawMax;
//using (ScadaContextDB ctx = new ScadaContextDB())
//{
// ctx.Analogs.Add(new ScadaCloud.Model.Analog
// {
// Name = uniqueName,
// NumOfRegisters = numOfReg,
// AcqValue = acqValue,
// CommValue = commValue,
// MaxValue = maxValue,
// MinValue = minValue,
// ProcContrName = procContr,
// RelativeAddress = relativeAddress,
// UnitSymbol = stringUnitSymbol
// });
// ctx.SaveChanges();
//}
// SETTING RawAcqValue and RawCommValue
AnalogProcessor.EGUToRawValue(newAnalog);
ushort calculatedRelativeAddres;
if (associatedRtu.TryMap(newAnalog, out calculatedRelativeAddres))
{
if (relativeAddress == calculatedRelativeAddres)
{
if (associatedRtu.MapProcessVariable(newAnalog))
{
dbContext.AddProcessVariable(newAnalog);
}
}
else
{
message = string.Format("Invalid config: Analog Variable = {0} RelativeAddress = {1} is not valid.", uniqueName, relativeAddress);
Console.WriteLine(message);
return(false);
}
}
}
else
{
message = string.Format("Invalid config: Name = {0} is not unique. Analog Variable already exists", uniqueName);
Console.WriteLine(message);
return(false);
}
}
else
{
message = string.Format("Invalid config: Parsing Analogs, ProcContrName = {0} does not exists.", procContr);
Console.WriteLine(message);
return(false);
}
}
}
// to do:
//if (counters.Count != 0)
//{
//}
Console.WriteLine("Configuration passed successfully.");
}
catch (FileNotFoundException e)
{
Console.WriteLine(e.Message);
return(false);
}
catch (XmlException e)
{
Console.WriteLine(e.Message);
return(false);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
return(false);
}
Database.IsConfigurationFinished = true;
return(true);
}
public static UnitSymbol GetDMSUnitSymbol(UnitSymbol unitSymbol)
{
switch (unitSymbol)
{
case UnitSymbol.A:
return(UnitSymbol.A);
case UnitSymbol.deg:
return(UnitSymbol.deg);
case UnitSymbol.degC:
return(UnitSymbol.degC);
case UnitSymbol.F:
return(UnitSymbol.F);
case UnitSymbol.g:
return(UnitSymbol.g);
case UnitSymbol.h:
return(UnitSymbol.h);
case UnitSymbol.H:
return(UnitSymbol.H);
case UnitSymbol.Hz:
return(UnitSymbol.Hz);
case UnitSymbol.J:
return(UnitSymbol.J);
case UnitSymbol.m:
return(UnitSymbol.m);
case UnitSymbol.m2:
return(UnitSymbol.m2);
case UnitSymbol.m3:
return(UnitSymbol.m3);
case UnitSymbol.min:
return(UnitSymbol.min);
case UnitSymbol.N:
return(UnitSymbol.N);
case UnitSymbol.ohm:
return(UnitSymbol.ohm);
case UnitSymbol.Pa:
return(UnitSymbol.Pa);
case UnitSymbol.rad:
return(UnitSymbol.rad);
case UnitSymbol.s:
return(UnitSymbol.s);
case UnitSymbol.S:
return(UnitSymbol.V);
case UnitSymbol.VA:
return(UnitSymbol.VA);
case UnitSymbol.VAh:
return(UnitSymbol.VAh);
case UnitSymbol.VAr:
return(UnitSymbol.VAr);
case UnitSymbol.VArh:
return(UnitSymbol.VArh);
case UnitSymbol.W:
return(UnitSymbol.W);
case UnitSymbol.Wh:
return(UnitSymbol.Wh);
default:
return(UnitSymbol.none);
}
}
