private void ParsePayload(Mini07ParseModel model)
{
_logger.LogTrace("Enter");
if (model.PayloadIndicator.ClientStatusPresent)
{
ParseClientStatuses(model);
}
_logger.LogDebug("DeviceSettingsPresent: {deviceSettingPresent}", model.PayloadIndicator.DeviceSettingPresent);
if (model.PayloadIndicator.DeviceSettingPresent)
{
ParseDeviceSettings(model);
}
ParseCounters(model);
if (model.PayloadIndicator.SmartMeterIsPresent)
{
var smartMeters = new[]
{
DeviceMeterType.Smart_Meter_EG, DeviceMeterType.Smart_Meter_E
};
if (smartMeters.Contains(model.MeterType))
{
ParseSmartMeter(model);
}
else if (model.MeterType == DeviceMeterType.Soladin_600)
{
ParseSoladin(model);
}
else
{
throw new BaseParserException("Invalid metertype for message payload parsing");
}
}
_logger.LogTrace("Exit");
}
protected override void DoParse()
{
_logger.LogTrace("Enter");
BaseParseResult.ProtocolNr = Reader.ReadByte();
BaseParseResult.SequenceNr = Reader.ReadByte();
var model = new Mini07ParseModel
{
Status = new QboxMiniStatus(Reader.ReadByte()),
MeasurementTime = Reader.ReadDateTime(),
MeterType = (DeviceMeterType)Reader.ReadByte(),
PayloadIndicator = new PayloaderIndicator(Reader.ReadByte())
};
if (!Enum.IsDefined(typeof(DeviceMeterType), model.MeterType))
{
throw new BaseParserException(String.Format("Unexpected metertype: {0}", model.MeterType));
}
if ((model.MeasurementTime - DateTime.Now).TotalHours > 3.0)
{
throw new BaseParserException(String.Format("Unreliable time {0}", model.MeasurementTime));
}
ParsePayload(model);
var miniParseResult = BaseParseResult as MiniParseResult;
if (miniParseResult != null)
{
miniParseResult.Model = model;
}
_logger.LogTrace("Exit");
}
protected virtual void AddCounterPayload(Mini07ParseModel model, CounterGroup group)
{
model.Payloads.Add(new CounterWithSourcePayload
{
InternalNr = Parser.ParseByte(),
Value = Parser.ParseUInt32(),
PrimaryMeter = group.PrimaryMeterCounters,
Source = group.CounterSource
});
}
protected override void AddCounterPayload(Mini07ParseModel model, CounterGroup group)
{
byte number = Reader.ReadByte();
model.Payloads.Add(new R21CounterPayload
{
InternalNr = number & 0x7F,
// Bit 7 (0x80) indicates if the counter value is valid (0) / invalid (1)
IsValid = (number & 0x80) == 0x00,
Value = Reader.ReadUInt32(),
PrimaryMeter = group.PrimaryMeterCounters,
Source = group.CounterSource
});
}
protected virtual void ParseCounters(Mini07ParseModel model)
{
_logger.LogDebug("Nr of counters: {nrOfCounters}", model.PayloadIndicator.NrOfCounters);
for (var i = 0; i < model.PayloadIndicator.NrOfCounters; i++)
{
try
{
model.Payloads.Add(new CounterPayload
{
InternalNr = Reader.ReadByte(),
Value = Reader.ReadUInt32()
});
}
catch (Exception ex)
{
throw new Exception(String.Format("Parsing counter payload (part {0} of {1})", i + 1, model.PayloadIndicator.NrOfCounters), ex);
}
}
}
protected override void ParseCounters(Mini07ParseModel model)
{
Logger.LogDebug("Nr of countergroups: {nrOfCounters}", model.PayloadIndicator.NrOfCounters);
int i = 0;
// Total number of counters
while (i < model.PayloadIndicator.NrOfCounters)
{
try
{
// Grouped per CounterGroup
var group = new CounterGroup(Parser.ParseByte());
for (var c = 0; c < group.NbrOfCounters; c++)
{
AddCounterPayload(model, group);
i++;
}
}
catch (Exception ex)
{
throw new Exception(String.Format("Parsing counter payload (payload {0} of {1})", i + 1, model.PayloadIndicator.NrOfCounters), ex);
}
}
}
