public DigitalChannelDirections(
DigitalChannel digiPort,
DigitalDirection digiDirection)
{
this.DigiPort = digiPort;
this.DigiDirection = digiDirection;
}
public Filter(DigitalChannel controlChannel)
{
if ((controlChannel == null))
{
throw new ArgumentNullException();
}
if (controlChannel.Width < 8)
{
throw new ArgumentException("Too narrow channel width");
}
_channel = controlChannel;
}
private ChannelData ExtractBitsFromLogicAnalyser(DigitalChannel ch, ChannelDataSourceScope t)
{
lock (dataLock)
{
//FIXME: expand for more than 1 LA
if (!data[t].ContainsKey(LogicAnalyserChannel.LA))
{
return(null);
}
Func <byte, bool> bitFilter = new Func <byte, bool>(x => Utils.IsBitSet(x, ch.Value));
var laChannel = data[t][LogicAnalyserChannel.LA];
data[t][ch] = new ChannelData(t, ch, Utils.TransformArray(laChannel.array, bitFilter), laChannel.partial, samplePeriod[t], offset[t]);
return(data[t][ch]);
}
}
private Channel ParseSeries(DigitalChannel digitalChannel)
{
Channel channel = new Channel();
Series series = new Series();
channel.Name = digitalChannel.ChannelName;
channel.HarmonicGroup = 0;
channel.MeasurementType = new MeasurementType();
channel.MeasurementType.Name = "Digital";
channel.MeasurementCharacteristic = new MeasurementCharacteristic();
channel.MeasurementCharacteristic.Name = "Unknown";
channel.Phase = new Phase();
channel.Phase.Name = !string.IsNullOrEmpty(digitalChannel.PhaseID) ? digitalChannel.PhaseID : "Unknown";
series.Channel = channel;
series.SeriesType = new SeriesType();
series.SeriesType.Name = "Values";
series.SourceIndexes = digitalChannel.Index.ToString();
return(channel);
}
private Channel ParseSeries(DigitalChannel digitalChannel)
{
string phaseName = !string.IsNullOrEmpty(digitalChannel.PhaseID) ? digitalChannel.PhaseID : "Unknown";
Series series = new Series();
series.Channel = new Channel();
series.SeriesType = new SeriesType()
{
Name = "Values"
};
series.SourceIndexes = digitalChannel.Index.ToString();
Channel channel = series.Channel;
channel.Series = new List <Series>()
{
series
};
channel.MeasurementType = new MeasurementType()
{
Name = "Digital"
};
channel.MeasurementCharacteristic = new MeasurementCharacteristic()
{
Name = "Unknown"
};
channel.Phase = new Phase()
{
Name = phaseName
};
channel.Name = digitalChannel.Name;
channel.Description = digitalChannel.CircuitComponent;
channel.HarmonicGroup = 0;
return(channel);
}
private void ExportToCOMTRADE(string filePath, ControlFile controlFile, string identityString, List <ANLG_CHNL_NEW> analogChannels, List <EVNT_CHNL_NEW> digitalChannels)
{
string assetKey = GetMeterKey(filePath, m_filePattern) ?? ThreadContext.Properties["Meter"].ToString();
string rootFileName = FilePath.GetFileNameWithoutExtension(filePath);
string directoryPath = Path.Combine(m_emaxSettings.COMTRADEExportDirectory, assetKey);
string schemaFilePath = Path.Combine(directoryPath, $"{rootFileName}.cfg");
string dataFilePath = Path.Combine(directoryPath, $"{rootFileName}.dat");
Schema comtradeSchema = new Schema();
if (File.Exists(dataFilePath))
{
return;
}
comtradeSchema.StationName = Regex.Replace(identityString, @"[\r\n]", "");
comtradeSchema.Version = 2013;
comtradeSchema.AnalogChannels = new AnalogChannel[controlFile.AnalogChannelCount];
comtradeSchema.DigitalChannels = new DigitalChannel[controlFile.EventChannelSettings.Count];
comtradeSchema.SampleRates = new SampleRate[1];
comtradeSchema.SampleRates[0].Rate = controlFile.SystemParameters.samples_per_second;
comtradeSchema.SampleRates[0].EndSample = controlFile.SystemParameters.rcd_sample_count - 1;
comtradeSchema.StartTime = new Timestamp()
{
Value = m_meterDataSet.DataSeries[1][0].Time
};
int triggerIndex = controlFile.SystemParameters.start_offset_samples + controlFile.SystemParameters.prefault_samples;
comtradeSchema.TriggerTime = new Timestamp()
{
Value = m_meterDataSet.DataSeries[1][triggerIndex].Time
};
for (int i = 0; i < analogChannels.Count; i++)
{
ANLG_CHNL_NEW analogChannel = analogChannels[i];
AnalogChannel comtradeAnalog = new AnalogChannel();
DataSeries channelData = m_meterDataSet.DataSeries[i + 1];
double unitMultiplier = 1.0D;
double max = channelData.Maximum;
double min = channelData.Minimum;
double num;
comtradeAnalog.Index = i + 1;
comtradeAnalog.Name = analogChannel.title;
comtradeAnalog.Units = new Func <string, string>(type =>
{
switch (type)
{
case "V": return("kVAC");
case "A": return("kAAC");
case "v": return(" VDC");
default: return(type);
}
})(analogChannel.type);
if (analogChannel.type.All(char.IsUpper))
{
unitMultiplier = 0.001D;
max *= unitMultiplier;
min *= unitMultiplier;
}
comtradeAnalog.Multiplier = (max - min) / (2 * short.MaxValue);
comtradeAnalog.Adder = (max + min) / 2.0D;
comtradeAnalog.PrimaryRatio = double.TryParse(analogChannel.primary, out num) ? num * unitMultiplier : 0.0D;
comtradeAnalog.SecondaryRatio = double.TryParse(analogChannel.secondary, out num) ? num * unitMultiplier : 0.0D;
comtradeSchema.AnalogChannels[i] = comtradeAnalog;
}
for (int i = 0; i < digitalChannels.Count; i++)
{
EVNT_CHNL_NEW digitalChannel = digitalChannels[i];
DigitalChannel comtradeDigital = new DigitalChannel();
comtradeDigital.Index = i + 1;
comtradeDigital.ChannelName = digitalChannel.e_title;
comtradeSchema.DigitalChannels[i] = comtradeDigital;
}
Directory.CreateDirectory(directoryPath);
File.WriteAllText(schemaFilePath, comtradeSchema.FileImage, Encoding.ASCII);
using (FileStream stream = File.OpenWrite(dataFilePath))
{
const int DigitalSize = sizeof(ushort) * 8;
IEnumerable <DataSeries> digitalWords = m_meterDataSet.Digitals.Skip(1)
.Select((dataSeries, index) => dataSeries.Multiply(Math.Pow(2.0D, DigitalSize - (index % DigitalSize) - 1)))
.Select((DataSeries, Index) => new { DataSeries, Index })
.GroupBy(obj => obj.Index / DigitalSize)
.Select(grouping => grouping.Select(obj => obj.DataSeries))
.Select(grouping => grouping.Aggregate((sum, series) => sum.Add(series)));
List <DataSeries> allChannels = m_meterDataSet.DataSeries.Skip(1)
.Select((dataSeries, index) => analogChannels[index].type.All(char.IsUpper) ? dataSeries.Multiply(0.001D) : dataSeries)
.Concat(digitalWords)
.ToList();
for (int i = 0; i < m_meterDataSet.DataSeries[1].DataPoints.Count; i++)
{
DateTime timestamp = m_meterDataSet.DataSeries[1][i].Time;
double[] values = allChannels
.Select(dataSeries => dataSeries[i].Value)
.ToArray();
Writer.WriteNextRecordBinary(stream, comtradeSchema, timestamp, values, (uint)i, false);
}
}
}
public ProgrammableGainAmplifier(DigitalChannel ControlChannel)
{
_channel = ControlChannel;
}
private ChannelData ExtractBitsFromLogicAnalyser(DigitalChannel ch, DataSourceType t)
{
lock (dataLock)
{
//FIXME: expand for more than 1 LA
if (!data[t].ContainsKey(LogicAnalyserChannel.LA))
return null;
Func<byte, bool> bitFilter = new Func<byte, bool>(x => Utils.IsBitSet(x, ch.Value));
var laChannel = data[t][LogicAnalyserChannel.LA];
data[t][ch] = new ChannelData(t, ch, Utils.TransformArray(laChannel.array, bitFilter), laChannel.partial, samplePeriod[t], offset[t]);
return data[t][ch];
}
}
private Schema WriteSchemaFile(COMTRADEData comtradeData, string schemaFilePath)
{
Schema schema = Writer.CreateSchema(new List <ChannelMetadata>(), comtradeData.StationName, comtradeData.DeviceID, comtradeData.DataStartTime, comtradeData.SampleCount, samplingRate: comtradeData.SamplingRate, includeFracSecDefinition: false, nominalFrequency: m_systemFrequency);
List <AnalogChannel> analogChannels = new List <AnalogChannel>();
List <DigitalChannel> digitalChannels = new List <DigitalChannel>();
int i = 1;
// Populate the analog channel list with analog channel metadata
foreach (COMTRADEChannelData channelData in comtradeData.AnalogChannelData)
{
AnalogChannel analogChannel = new AnalogChannel();
analogChannel.Index = i;
analogChannel.Name = channelData.Name;
analogChannel.MinValue = -short.MaxValue;
analogChannel.MaxValue = short.MaxValue;
analogChannel.Units = channelData.Units;
if ((object)channelData.OriginalAnalogChannel != null)
{
analogChannel.PhaseID = channelData.OriginalAnalogChannel.PhaseID;
analogChannel.CircuitComponent = channelData.OriginalAnalogChannel.CircuitComponent;
analogChannel.Units = channelData.OriginalAnalogChannel.Units;
analogChannel.Skew = channelData.OriginalAnalogChannel.Skew;
analogChannel.PrimaryRatio = channelData.OriginalAnalogChannel.PrimaryRatio;
analogChannel.SecondaryRatio = channelData.OriginalAnalogChannel.SecondaryRatio;
analogChannel.ScalingIdentifier = channelData.OriginalAnalogChannel.ScalingIdentifier;
if (analogChannel.Units.ToUpper().Contains("KA") || analogChannel.Units.ToUpper().Contains("KV"))
{
channelData.Data = channelData.Data.Multiply(0.001);
}
}
analogChannel.Multiplier = (channelData.Data.Maximum - channelData.Data.Minimum) / (2 * short.MaxValue);
analogChannel.Adder = (channelData.Data.Maximum + channelData.Data.Minimum) / 2.0D;
analogChannels.Add(analogChannel);
i++;
}
i = 1;
// Populate the digital channel list with digital channel metadata
foreach (COMTRADEChannelData channelData in comtradeData.DigitalChannelData)
{
DigitalChannel digitalChannel = new DigitalChannel();
digitalChannel.Index = i;
digitalChannel.Name = channelData.Name;
if ((object)channelData.OriginalDigitalChannel != null)
{
digitalChannel.PhaseID = channelData.OriginalDigitalChannel.PhaseID;
digitalChannel.CircuitComponent = channelData.OriginalDigitalChannel.CircuitComponent;
digitalChannel.NormalState = channelData.OriginalDigitalChannel.NormalState;
}
digitalChannels.Add(digitalChannel);
i++;
}
schema.AnalogChannels = analogChannels.ToArray();
schema.DigitalChannels = digitalChannels.ToArray();
// Dump the generated schema to the schema file
File.WriteAllText(FilePath.GetAbsolutePath(schemaFilePath), schema.FileImage, Encoding.ASCII);
// Return the schema
return(schema);
}
public DigitalChannelDirections(DigitalChannel channel, DigitalDirection direction)
{
Channel = channel;
Direction = direction;
}
