public CommandPartSearcherPsnConfigBasedFast(IPsnProtocolConfiguration psnProtocolConfiguration)
{
_cmdPartConfigs = psnProtocolConfiguration.CommandParts.ToList();
_cmdPartsCount = _cmdPartConfigs.Count;
_commandPartSearcher = new PsnCommandPartSearcherAllDefinedValuesAndCrc();
}
public void FillResources(
IPsnProtocolConfiguration protocol,
DateTime beginTime,
IEnumerable <IPsnProtocolCommandPartConfigurationCycle> cycleCmdPartInfo,
IEnumerable <IPsnProtocolCommandPartConfiguration> commandPartsToMap)
{
var goodCommandParts = protocol.CommandParts.Where(cp =>
cp.Address != null && cp.CommandCode != null && cp.CrcHigh != null && cp.CrcLow != null).ToArray();
byte[] dataBytes;
using (var dataStream = _dataStreamGetter.Invoke())
{
dataBytes = new byte[dataStream.Length];
dataStream.Read(dataBytes, 0, (int)dataStream.Length);
}
if (_pagesIndex == null)
{
var fr = BuildPagesIndex(dataBytes);
_pagesIndex = fr.FullIndex;
_timeSortedGoodPages = fr.TimeSortedGoodPages;
_goodPagesOnlyGoodBytes = GetOnlyGoodData(fr.TimeSortedGoodPages, dataBytes);
_commandsMap = BuildCommandsMap(goodCommandParts, cycleCmdPartInfo, _goodPagesOnlyGoodBytes, beginTime,
_timeSortedGoodPages);
}
_lastPsnProtocolId = protocol.Information.Id;
_areResourcesFree = false;
}
public PsnChannelDataHandler(IPsnDataHandler dataHandler, IPsnProtocolCommandPartConfiguration psnCommandPart, IPsnProtocolParameterConfiguration psnParameterConfig, IPsnProtocolConfiguration configuration)
{
_psnDataHandler = dataHandler;
_psnCommandPart = psnCommandPart;
_psnParameterConfig = psnParameterConfig;
_configuration = configuration;
}
public List <DataPoint> GetDataPoints(IPsnProtocolConfiguration protocol,
IPsnProtocolCommandPartConfiguration commandPart, IPsnProtocolParameterConfiguration paramInfo,
DateTime beginTime)
{
// Если конфигурация была изменена:
if (_lastPsnProtocolId != null && _lastPsnProtocolId.IdentyString != protocol.Information.Id.IdentyString)
{
FreeResources();
}
if (_areResourcesFree)
{
FillResources(protocol, beginTime, protocol.CycleCommandParts, protocol.CommandParts);
}
var result = new List <DataPoint>();
bool isWatchForRequestNeeded;
Func <IPsnMapRecord, IPsnMapSubrecord> funcGetPart;
if (commandPart.PartType == PsnProtocolCommandPartType.Request)
{
funcGetPart = FuncGetPartRequest;
isWatchForRequestNeeded = false;
}
else if (commandPart.PartType == PsnProtocolCommandPartType.Reply)
{
funcGetPart = FuncGetPartReply;
isWatchForRequestNeeded = false;
}
else /*if (commandPart.PartType == PsnProtocolCommandPartType.ReplyWithRequiredRequest)*/
{
funcGetPart = FuncGetPartReply;
isWatchForRequestNeeded = true;
}
// поток данных нужен для извлечения самих данных (т.к. изначально их нет в карте (есть только информация о местоположении и времени команд протокола ПСН)
// можно разделить алгоритм на две части: выборку из карты инфомрации об интересующем сигнале, а затем - заполнение значений из потока данных
for (int i = 0; i < _commandsMap.Count; ++i)
{
if (_commandsMap[i].CommandId.IdentyString == commandPart.CommandId.IdentyString)
{
IPsnMapSubrecord needRec = funcGetPart.Invoke(_commandsMap[i]);
if (needRec != null)
{
if (isWatchForRequestNeeded && _commandsMap[i].RequestRecordInfo != null ||
!isWatchForRequestNeeded)
{
// CRC ok
int positionInGoodData = needRec.LocationInfo.Position;
result.Add(new DataPoint(paramInfo.GetValue(_goodPagesOnlyGoodBytes, positionInGoodData),
needRec.LocationInfo.Time, true, positionInGoodData));
}
}
}
}
return(result);
}
/// <summary>
/// Для всех сигналов, относящихся к определенному измерителю
/// </summary>
/// <param name="psnConfig">Конфигурация ПСН</param>
/// <param name="meterAddress">Адрес измерителя</param>
/// <param name="progressAction">Действие при очередном нахождении конфигурации сигнала, если вернет истину - то метод остановится</param>
public static void ForeachPsnMeterSignal(this IPsnProtocolConfiguration psnConfig, int meterAddress, Func <IPsnProtocolCommandPartConfiguration, IPsnProtocolParameterConfiguration, bool> progressAction)
{
foreach (var cmdPart in psnConfig.CommandParts)
{
if (cmdPart != null)
{
if (cmdPart.Address != null)
{
if (cmdPart.Address.DefinedValue == meterAddress)
{
foreach (var param in cmdPart.VarParams)
{
if (!param.Name.StartsWith("#"))
{
if (progressAction(cmdPart, param))
{
return;
}
}
}
}
}
}
}
}
public PsnChannelTrendLoaderSimple(IPsnProtocolParameterConfiguration signalConfiguration, IPsnProtocolCommandPartConfiguration commandPartConfiguration, IPsnData psnData, IPsnProtocolConfiguration psnConfiguration, IPsnDataInformation psnDataInformation)
{
_signalConfiguration = signalConfiguration;
_commandPartConfiguration = commandPartConfiguration;
_psnData = psnData;
_psnConfiguration = psnConfiguration;
_psnDataInformation = psnDataInformation;
}
public PsnChannelTrendLoaderMerged(IPsnMergedParameter mergedParam, IPsnData psnData, IPsnProtocolConfiguration psnConfiguration, IPsnDataInformation psnDataInformation)
{
_mergedParam = mergedParam;
_psnData = psnData;
_psnConfiguration = psnConfiguration;
_psnDataInformation = psnDataInformation;
_loadedTrendsCount = 0;
}
public void LoadTrend(IPsnProtocolConfiguration configuration, IPsnProtocolCommandPartConfiguration psnCommandPart, IPsnProtocolParameterConfiguration psnParameterConfig, DateTime beginTime, Action <DataPoint> nextPointLoaded)
{
if (_loadedTrendsCount == 0)
{
_psnDataHandler.FillResources(configuration, beginTime, configuration.CycleCommandParts, configuration.CommandParts);
}
new PsnChannelDataHandler(_psnDataHandler, psnCommandPart, psnParameterConfig, configuration).GetDataPoints(beginTime, nextPointLoaded);
_loadedTrendsCount++;
}
public static void Serialize(string filename, IPsnProtocolConfiguration config, bool includeCustomName)
{
var xDoc = new XDocument();
var rootElement = new XElement("Parameters");
AddChildXmlNodesWithParameters(rootElement, config, includeCustomName);
xDoc.Add(rootElement);
xDoc.Save(filename);
}
public List <DataPoint> LoadTrend(IPsnProtocolConfiguration configuration, IPsnProtocolCommandPartConfiguration psnCommandPart, IPsnProtocolParameterConfiguration psnParameterConfig, DateTime beginTime)
{
if (_loadedTrendsCount == 0)
{
_psnDataHandler.FillResources(configuration, beginTime, configuration.CycleCommandParts, configuration.CommandParts);
}
var result = new PsnChannelDataHandler(_psnDataHandler, psnCommandPart, psnParameterConfig, configuration).GetDataPoints(beginTime);
_loadedTrendsCount++;
return(result);
}
public SharedAppAbilities(string psnProtocolFileName)
{
var isFullVersion = File.Exists("FullVersion.txt");
var isHalfOrFullVersion = isFullVersion;
if (!isHalfOrFullVersion)
{
isHalfOrFullVersion = File.Exists("HalfVersion.txt");
}
Version = isFullVersion ? AppVersion.Full :
isHalfOrFullVersion ? AppVersion.Half : AppVersion.Base;
IsHourCountersVisible = File.Exists("HourCounters.txt");
PsnProtocolConfiguration = new PsnProtocolConfigurationLoaderFromXml(Path.Combine(Environment.CurrentDirectory, psnProtocolFileName)).LoadConfiguration();
var allPsnParams = new Dictionary <string, Tuple <IPsnProtocolCommandPartConfiguration, IPsnProtocolParameterConfigurationVariable> >();
foreach (var psnCommandPart in PsnProtocolConfiguration.CommandParts)
{
foreach (var param in psnCommandPart.VarParams)
{
allPsnParams.Add(param.Id.IdentyString, new Tuple <IPsnProtocolCommandPartConfiguration, IPsnProtocolParameterConfigurationVariable>(psnCommandPart, param));
}
}
PsnProtocolConfigurationParams = allPsnParams;
RtuParamReceiver = new ModbusRtuParamReceiver();
CmdNotifierStd = new StdNotifier();
CmdNotifierStd.AddListener(RtuParamReceiver);
_channels = new Dictionary <string, SerialChannelWithTimeoutMonitorAndSendReplyAbility>();
var paramLoggerAndRegPoint = new ParamLoggerRegistrationPointThreadSafe();
ParameterLogger = paramLoggerAndRegPoint;
ParamLoggerRegistrationPoint = paramLoggerAndRegPoint;
var paramListener = new CommandPartAndParamListenerSimple(CmdNotifierStd);
foreach (var cmdPart in PsnProtocolConfiguration.CommandParts)
{
paramListener.AddPsnCommandPartConfigurationToListen(cmdPart);
}
ParamListener = paramListener;
CommandPartListener = paramListener;
}
public void Update(IPsnConfiguration psnConfig, string customName)
{
// TODO: improve threading
// Предполагается, что метод вызывается из потока UI
_psnConfiguration = psnConfig;
_psnDataCustomConfigration.SetPsnConfigurationId(new IdentifierStringToLowerBased(_psnConfiguration.Id.ToString().ToLower()));
_psnDataCustomConfigration.SetCustomLogName(customName);
_bworker.AddToQueueAndWaitExecution(() => {
_psnDataCustomConfigurationStorage.Update(_psnDataCustomConfigration.Id, new IdentifierStringToLowerBased(_psnConfiguration.Id.ToString().ToLower()), customName);
_psnConfigurationLowLevel = _psnProtocolStorage.StoredItems.First(lowConfig => lowConfig.Id.IdentyString == _psnConfiguration.Id.ToString().ToLower());
});
RebuildMetersUnsafe();
}
public PsnParamsListSimple(IPsnProtocolConfiguration protocolConfig)
{
var allPsnParams =
new Dictionary <string, Tuple <IPsnProtocolCommandPartConfiguration,
IPsnProtocolParameterConfigurationVariable> >();
foreach (var psnCommandPart in protocolConfig.CommandParts)
{
foreach (var param in psnCommandPart.VarParams)
{
allPsnParams.Add(param.Id.IdentyString,
new Tuple <IPsnProtocolCommandPartConfiguration, IPsnProtocolParameterConfigurationVariable>(
psnCommandPart, param));
}
}
PsnProtocolConfigurationParams = allPsnParams;
}
/// <summary>
/// Для всех сигналов конфигурации
/// </summary>
/// <param name="psnConfig">Конфигурация ПСН</param>
/// <param name="progressAction">Действие при очередном нахождении конфигурации сигнала, если вернет истину - то метод остановится</param>
public static void ForeachPsnParameterConfig(this IPsnProtocolConfiguration psnConfig, Func <IPsnProtocolCommandPartConfiguration, IPsnProtocolParameterConfiguration, bool> progressAction)
{
foreach (var cmdPart in psnConfig.CommandParts)
{
if (cmdPart != null)
{
if (cmdPart.Address != null)
{
foreach (var param in cmdPart.VarParams)
{
if (progressAction(cmdPart, param))
{
return;
}
}
}
}
}
}
public PsnLogRelay(
IPsnDataInformation psnDataInformation,
IPsnData psnData,
IPsnConfiguration psnConfiguration,
IPsnProtocolConfiguration psnConfigurationLowLevel,
IPsnDataCustomConfigration psnDataCustomConfigration,
IThreadNotifier uiNotifier,
IWorker <Action> bworker,
IStorage <IPsnProtocolConfiguration> psnProtocolStorage,
IPsnDataCustomConfigurationsStorage psnDataCustomConfigurationStorage,
IKeyValueStorageHolder repoStorageHolder)
{
_logIntegrity = PsnLogIntegrity.Unknown;
_psnDataInformation = psnDataInformation;
_psnData = psnData;
_psnDataPaged = _psnData.PagesInformation;
_psnConfiguration = psnConfiguration;
_psnConfigurationLowLevel = psnConfigurationLowLevel;
_psnDataCustomConfigration = new PsnDataCustomConfigurationSimple(
psnDataCustomConfigration.Id,
psnDataCustomConfigration.PsnConfigurationId,
psnDataCustomConfigration.CustomLogName);
_uiNotifier = uiNotifier;
_bworker = bworker;
_psnProtocolStorage = psnProtocolStorage;
_psnDataCustomConfigurationStorage = psnDataCustomConfigurationStorage;
_meters = new ObservableCollection <IPsnMeter>();
// TODO: i get logs for FTP logs also
//_unicSignalIdStorage = new KeyValueStringStorageXmlMemCache(Path.Combine(Support.GetAppDataDirectoryPathAndCreateItIfNeeded(), Id.UnicString + ".Id.xml"));
_unicSignalIdStorage = repoStorageHolder.GetStorage(Id.UnicString);
//_unicSignalIdStorage = new KvStorageDbreezed(Id.UnicString);
RebuildMetersUnsafe();
}
private static void LoadAllStoragedSignals(IPsnDataStorage storage, IPsnProtocolConfiguration config)
{
var psnLogsInStorage = storage.PsnDatas.ToList();
Log("Число ПСН логов на устройстве: " + psnLogsInStorage.Count);
Log("Конфигурация ПСН: " + config.Information);
Log("Загрузка всех сигналов для всех логов...");
foreach (var psnLog in psnLogsInStorage)
{
Console.WriteLine("PsnLog " + psnLog);
foreach (var psnDev in config.PsnDevices)
{
Log("Работаем с абонентом ПСН: " + psnDev.Name);
IPsnData log = psnLog;
IPsnProtocolDeviceConfiguration dev = psnDev;
config.ForeachPsnMeterSignal(psnDev.Address, (cmdPartConfiguration, parameterConfiguration) => {
var points = log.LoadTrend(config, cmdPartConfiguration, parameterConfiguration, DateTime.Now);
Console.WriteLine(dev.Name + "/" + parameterConfiguration.Name + " = " + points.Count);
return(false);
});
}
}
}
private static void AddChildXmlNodesWithParameters(XElement parametersRootElement,
IPsnProtocolConfiguration config, bool includeCustomName)
{
foreach (var commandPart in config.CommandParts)
{
var address = (int)commandPart.Address.DefinedValue;
var command = (int)commandPart.CommandCode.DefinedValue;
var signalNumber = 1;
foreach (var varParam in commandPart.VarParams)
{
if (varParam.Name.StartsWith("#"))
{
continue;
}
var key = "param_" +
address.ToString("d3") + "_" +
command.ToString("d3") + "_" +
(commandPart.PartType == PsnProtocolCommandPartType.Request ? "request_" : "reply_") +
signalNumber.ToString("d3");
var node = new XElement("Parameter", new XAttribute("Key", key),
new XAttribute("Identifier", varParam.Id.IdentyString));
if (includeCustomName)
{
node.Add(new XAttribute("CustomName", varParam.Name));
}
node.Add(new XAttribute("Comment", commandPart.PartName + " - " + varParam.Name));
parametersRootElement.Add(node);
signalNumber++;
}
}
}
public PsnProtocolConfigBuilderFromLowLevel(IPsnProtocolConfiguration psnInternalConfig)
{
_psnInternalConfig = psnInternalConfig;
}
public CommandPartAndParamListenerSimple(IIOListener ioListener, IPsnProtocolConfiguration configuration)
{
_stdListener = ioListener;
_configuration = configuration;
_stdListener.CommandPartHeared += StdListenerCommandPartHeared;
}
