private IScadaModelPointItem CreatePointItemFromResource(ResourceDescription resource)
{
long gid = resource.Id;
ModelCode type = modelResourceDesc.GetModelCodeFromId(gid);
IScadaModelPointItem pointItem;
if (type == ModelCode.ANALOG)
{
pointItem = new AnalogPointItem(AlarmConfigDataHelper.GetAlarmConfigData());
pointItemHelper.InitializeAnalogPointItem(pointItem as AnalogPointItem, resource.Properties, type, enumDescs);
}
else if (type == ModelCode.DISCRETE)
{
pointItem = new DiscretePointItem(AlarmConfigDataHelper.GetAlarmConfigData());
pointItemHelper.InitializeDiscretePointItem(pointItem as DiscretePointItem, resource.Properties, type, enumDescs);
}
else
{
string errMessage = $"{baseLogString} CreatePointItemFromResource => ResourceDescription type is neither analog nor digital. Type: {type}.";
Logger.LogWarning(errMessage);
pointItem = null;
}
return(pointItem);
}
public void InitializeAnalogPointItem(AnalogPointItem pointItem, List <Property> props, ModelCode type, EnumDescs enumDescs)
{
InitializeScadaModelPointItem(pointItem as ScadaModelPointItem, props, type, enumDescs);
foreach (var item in props)
{
switch (item.Id)
{
case ModelCode.ANALOG_CURRENTVALUE:
pointItem.CurrentEguValue = item.AsFloat();
break;
case ModelCode.ANALOG_MAXVALUE:
pointItem.EGU_Max = item.AsFloat();
break;
case ModelCode.ANALOG_MINVALUE:
pointItem.EGU_Min = item.AsFloat();
break;
case ModelCode.ANALOG_NORMALVALUE:
pointItem.NormalValue = item.AsFloat();
break;
case ModelCode.ANALOG_SCALINGFACTOR:
pointItem.ScalingFactor = item.AsFloat();
break;
case ModelCode.ANALOG_DEVIATION:
pointItem.Deviation = item.AsFloat();
break;
case ModelCode.ANALOG_SIGNALTYPE:
pointItem.AnalogType = (AnalogMeasurementType)(enumDescs.GetEnumValueFromString(ModelCode.ANALOG_SIGNALTYPE, item.AsEnum().ToString()));
break;
default:
break;
}
}
if (pointItem.ScalingFactor == 0)
{
string warnMessage = $"{baseLogString} InitializeAnalogPointItem => Analog measurement is of type: {pointItem.AnalogType} which is not supported for alarming. Gid: 0x{pointItem.Gid:X16}, Addres: {pointItem.Address}, Name: {pointItem.Name}, RegisterType: {pointItem.RegisterType}, Initialized: {pointItem.Initialized}";
Logger.LogWarning(warnMessage);
pointItem.ScalingFactor = 1;
}
pointItem.Initialized = true;
}
private async Task <bool> ImportAnalog()
{
bool success;
int numberOfResources = 1000;
List <ModelCode> props = modelResourceDesc.GetAllPropertyIds(ModelCode.ANALOG);
try
{
var nmsGdaClient = NetworkModelGdaClient.CreateClient();
int iteratorId = await nmsGdaClient.GetExtentValues(ModelCode.ANALOG, props);
int resourcesLeft = await nmsGdaClient.IteratorResourcesLeft(iteratorId);
while (resourcesLeft > 0)
{
List <ResourceDescription> rds = await nmsGdaClient.IteratorNext(numberOfResources, iteratorId);
for (int i = 0; i < rds.Count; i++)
{
if (rds[i] == null)
{
continue;
}
long gid = rds[i].Id;
ModelCode type = modelResourceDesc.GetModelCodeFromId(gid);
AnalogPointItem analogPoint = new AnalogPointItem(AlarmConfigDataHelper.GetAlarmConfigData());
string debugMessage = $"{baseLogString} ImportAnalog => Before Initialization => Gid: 0x{analogPoint.Gid:X16}, Address: {analogPoint.Address}, CurrentRawValue: {analogPoint.CurrentRawValue}, Alarm: {analogPoint.Alarm}, ScalingFactor: {analogPoint.ScalingFactor}, Deviation: {analogPoint.Deviation}, MinRawValue: {analogPoint.MinRawValue}, MaxRawValue: {analogPoint.MaxRawValue}, NormalValue: {analogPoint.NormalValue}, RegisterType: {analogPoint.RegisterType}, Name: {analogPoint.Name}, Initialized: {analogPoint.Initialized}";
Logger.LogDebug(debugMessage);
pointItemHelper.InitializeAnalogPointItem(analogPoint, rds[i].Properties, ModelCode.ANALOG, enumDescs);
debugMessage = $"{baseLogString} ImportAnalog => After Initialization => Gid: 0x{analogPoint.Gid:X16}, Address: {analogPoint.Address}, CurrentRawValue: {analogPoint.CurrentRawValue}, Alarm: {analogPoint.Alarm}, ScalingFactor: {analogPoint.ScalingFactor}, Deviation: {analogPoint.Deviation}, MinRawValue: {analogPoint.MinRawValue}, MaxRawValue: {analogPoint.MaxRawValue}, NormalValue: {analogPoint.NormalValue}, RegisterType: {analogPoint.RegisterType}, Name: {analogPoint.Name}, Initialized: {analogPoint.Initialized}";
Logger.LogDebug(debugMessage);
if (await GidToPointItemMap.ContainsKeyAsync(gid))
{
string errorMessage = $"{baseLogString} ImportAnalog => SCADA model is invalid => Gid: 0x{gid:16} belongs to more than one entity.";
Logger.LogError(errorMessage);
throw new InternalSCADAServiceException(errorMessage);
}
await GidToPointItemMap.SetAsync(gid, analogPoint);
#if DEBUG
var pointItemResult = await GidToPointItemMap.TryGetValueAsync(gid);
if (pointItemResult.HasValue)
{
AnalogPointItem controlPointItem = pointItemResult.Value as AnalogPointItem;
debugMessage = $"{baseLogString} ImportAnalog => Control after CurrentGidToPointItemMap.SetAsync => Gid: 0x{controlPointItem.Gid:X16}, Address: {controlPointItem.Address}, CurrentRawValue: {controlPointItem.CurrentRawValue}, Alarm: {controlPointItem.Alarm}, ScalingFactor: {controlPointItem.ScalingFactor}, Deviation: {controlPointItem.Deviation}, MinRawValue: {controlPointItem.MinRawValue}, MaxRawValue: {controlPointItem.MaxRawValue}, NormalValue: {controlPointItem.NormalValue}, RegisterType: {controlPointItem.RegisterType}, Name: {controlPointItem.Name}, Initialized: {controlPointItem.Initialized}";
Logger.LogDebug(debugMessage);
}
else
{
string warningMessage = $"{baseLogString} ImportAnalog => Control after CurrentGidToPointItemMap.SetAsync => Gid: 0x{gid:X16} was not found in reliable collection '{ReliableDictionaryNames.GidToPointItemMap}' after the value was supposedly set.";
Logger.LogWarning(warningMessage);
}
#endif
short registerType = (short)analogPoint.RegisterType;
if (!(await AddressToGidMap.ContainsKeyAsync(registerType)))
{
await AddressToGidMap.SetAsync(registerType, new Dictionary <ushort, long>());
}
var addressToGidDictionaryResult = await AddressToGidMap.TryGetValueAsync(registerType);
if (!addressToGidDictionaryResult.HasValue)
{
string message = $"{baseLogString} ImportAnalog => reliable collection '{ReliableDictionaryNames.AddressToGidMap}' is not initialized properly.";
Logger.LogError(message);
throw new InternalSCADAServiceException(message);
}
var addressToGidDictionary = addressToGidDictionaryResult.Value;
if (addressToGidDictionary.ContainsKey(analogPoint.Address))
{
string message = $"{baseLogString} ImportAnalog => SCADA model is invalid => Address: {analogPoint.Address} (RegType: {registerType}) belongs to more than one entity.";
Logger.LogError(message);
throw new InternalSCADAServiceException(message);
}
addressToGidDictionary.Add(analogPoint.Address, rds[i].Id);
await AddressToGidMap.SetAsync(registerType, addressToGidDictionary);
debugMessage = $"{baseLogString} ImportAnalog => ANALOG measurement added to SCADA model [Gid: 0x{gid:X16}, Address: {analogPoint.Address}]";
Logger.LogDebug(debugMessage);
}
resourcesLeft = await nmsGdaClient.IteratorResourcesLeft(iteratorId);
}
await nmsGdaClient.IteratorClose(iteratorId);
success = true;
}
catch (Exception ex)
{
success = false;
string errorMessage = $"{baseLogString} ImportAnalog => failed with error: {ex.Message}";
Trace.WriteLine(errorMessage);
Logger.LogError(errorMessage, ex);
}
return(success);
}
