diff --git a/apps/ccam/CMakeLists.txt b/apps/ccam/CMakeLists.txt index 26da617..65e5f44 100644 --- a/apps/ccam/CMakeLists.txt +++ b/apps/ccam/CMakeLists.txt @@ -1,7 +1,16 @@ set(SOURCES configuration.h) set(SOURCES statehandlerutils.h) +# Allow warnings for paho.mqtt.cpp +if ( ROSA_COMPILER_IS_GCC_COMPATIBLE ) + remove("-Werror" CMAKE_CXX_FLAGS) +elseif ( MSVC ) + remove("/WX" CMAKE_CXX_FLAGS) +endif() + ROSA_add_app(ccam ccam.cpp) ROSA_add_library_dependencies(ccam ROSAConfig) ROSA_add_library_dependencies(ccam ROSAApp) ROSA_add_library_dependencies(ccam ROSAAgent) +ROSA_add_library_dependencies(mqtt-client paho-mqttpp3) +ROSA_add_library_dependencies(mqtt-client paho-mqttc3::MQTTAsync) diff --git a/apps/ccam/ccam.cpp b/apps/ccam/ccam.cpp index c110fe7..5f89a79 100644 --- a/apps/ccam/ccam.cpp +++ b/apps/ccam/ccam.cpp @@ -1,531 +1,545 @@ //===-- apps/ccam/ccam.cpp --------------------------------------*- C++ -*-===// // // The RoSA Framework -- Application CCAM // // Distributed under the terms and conditions of the Boost Software /// License 1.0. // See accompanying file LICENSE. // // If you did not receive a copy of the license file, see // http://www.boost.org/LICENSE_1_0.txt. // //===----------------------------------------------------------------------===// /// /// \file apps/ccam/ccam.cpp /// /// \author Maximilian Goetzinger (maximilian.goetzinger@tuwien.ac.at) /// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at) /// /// \date 2019 /// /// \brief The application CCAM implements the case study from the paper: /// M. Goetzinger, N. TaheriNejad, H. A. Kholerdi, A. Jantsch, E. Willegger, /// T. Glatzl, A.M. Rahmani, T.Sauter, P. Liljeberg: Model - Free Condition /// Monitoring with Confidence /// /// \todo Clean up source files of this app: add standard RoSA header comment /// for own files and do something with 3rd party files... //===----------------------------------------------------------------------===// #include "rosa/agent/Abstraction.hpp" #include "rosa/agent/Confidence.hpp" #include "rosa/agent/FunctionAbstractions.hpp" #include #include "rosa/config/version.h" #include "rosa/agent/SignalStateDetector.hpp" #include "rosa/agent/SystemStateDetector.hpp" #include "rosa/app/Application.hpp" #include "rosa/support/csv/CSVReader.hpp" #include "rosa/support/csv/CSVWriter.hpp" +#include "rosa/support/mqtt/MQTTReader.hpp" + #include "rosa/app/AppTuple.hpp" #include #include #include #include #include "configuration.h" #include "statehandlerutils.h" using namespace rosa; using namespace rosa::agent; using namespace rosa::app; using namespace rosa::terminal; const std::string AppName = "CCAM"; int main(int argc, char **argv) { LOG_INFO_STREAM << '\n' << library_string() << " -- " << Color::Red << AppName << "app" << Color::Default << '\n'; // // Read the filepath of the config file of the observed system. The filepath // is in the first argument passed to the application. Fuzzy functions etc. // are described in this file. // if (argc < 2) { LOG_ERROR("Specify config File!\nUsage:\n\tccam config.json"); return 1; } std::string ConfigPath = argv[1]; // // Load config file and read in all parameters. Fuzzy functions etc. are // described in this file. // if (!readConfigFile(ConfigPath)) { LOG_ERROR_STREAM << "Could not read config from \"" << ConfigPath << "\"\n"; return 2; } // // Create a CCAM context. // LOG_INFO("Creating Context"); std::unique_ptr AppCCAM = Application::create(AppName); // // Create following function which shall give information if the time gap // between changed input(s) and changed output(s) shows already a malfunction // of the system. // // ____________ // / // / // __________/ // std::shared_ptr> BrokenDelayFunction( new PartialFunction( {{{0, AppConfig.BrokenCounter}, std::make_shared>( 0, 0.f, AppConfig.BrokenCounter, 1.f)}, {{AppConfig.BrokenCounter, std::numeric_limits::max()}, std::make_shared>(1.f, 0.f)}}, 0.f)); // // Create following function which shall give information if the time gap // between changed input(s) and changed output(s) still shows a // well-functioning system. // // ____________ // \ - // \ - // \__________ + // \ + // \__________ // std::shared_ptr> OkDelayFunction( new PartialFunction( {{{0, AppConfig.BrokenCounter}, std::make_shared>( 0, 1.f, AppConfig.BrokenCounter, 0.f)}, {{AppConfig.BrokenCounter, std::numeric_limits::max()}, std::make_shared>(0.f, 0.f)}}, 1.f)); // // Create a AppAgent with SystemStateDetector functionality. // LOG_INFO("Create SystemStateDetector agent."); AgentHandle SystemStateDetectorAgent = createSystemStateDetectorAgent( AppCCAM, "SystemStateDetector", AppConfig.SignalConfigurations.size(), BrokenDelayFunction, OkDelayFunction); // // Set policy of SystemStateDetectorAgent that it wait for all // SignalStateDetectorAgents // std::set pos; for (size_t i = 0; i < AppConfig.SignalConfigurations.size(); ++i) pos.insert(pos.end(), i); AppCCAM->setExecutionPolicy(SystemStateDetectorAgent, AppExecutionPolicy::awaitAll(pos)); // // Create Vectors for all sensors, all signal related fuzzy functions, all // signal state detectors, all signal state agents, and all input data files. // LOG_INFO("Creating sensors, SignalStateDetector functionalities and their " "Abstractions."); std::vector Sensors; std::vector>> SampleMatchesFunctions; std::vector>> SampleMismatchesFunctions; std::vector>> SignalIsStableFunctions; std::vector>> SignalIsDriftingFunctions; std::vector>> NumOfSamplesMatchFunctions; std::vector>> NumOfSamplesMismatchFunctions; std::vector>> SampleValidFunctions; std::vector>> SampleInvalidFunctions; std::vector>> NumOfSamplesValidFunctions; std::vector>> NumOfSamplesInvalidFunctions; std::vector>> SignalStateDetectors; std::vector SignalStateDetectorAgents; std::vector DataFiles; // // Go through all signal state configurations (number of signals), and create // functionalities for SignalStateDetector. // for (auto SignalConfiguration : AppConfig.SignalConfigurations) { // // Create application sensors. // Sensors.emplace_back( AppCCAM->createSensor(SignalConfiguration.Name + "_Sensor")); // // Create following function(s) which shall give information whether one // sample matches another one (based on the relative distance between them). // // ____________ // / \ - // / \ - // __________/ \__________ + // / \ + // __________/ \__________ // // SampleMatchesFunctions.emplace_back(new PartialFunction( { {{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound}, std::make_shared>( -SignalConfiguration.OuterBound, 0.f, -SignalConfiguration.InnerBound, 1.f)}, {{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound}, std::make_shared>(1.f, 0.f)}, {{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound}, std::make_shared>( SignalConfiguration.InnerBound, 1.f, SignalConfiguration.OuterBound, 0.f)}, }, 0)); // // Create following function(s) which shall give information whether one // sample mismatches another one (based on the relative distance between // them). // // ____________ ____________ // \ / // \ / // \__________/ // // SampleMismatchesFunctions.emplace_back(new PartialFunction( { {{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound}, std::make_shared>( -SignalConfiguration.OuterBound, 1.f, -SignalConfiguration.InnerBound, 0.f)}, {{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound}, std::make_shared>(0.f, 0.f)}, {{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound}, std::make_shared>( SignalConfiguration.InnerBound, 0.f, SignalConfiguration.OuterBound, 1.f)}, }, 1)); // // Create following function(s) which shall give information whether a // signal is stable. // // ____________ // / \ - // / \ - // __________/ \__________ + // / \ + // __________/ \__________ // // SignalIsStableFunctions.emplace_back(new PartialFunction( { {{-SignalConfiguration.OuterBoundDrift, -SignalConfiguration.InnerBoundDrift}, std::make_shared>( -SignalConfiguration.OuterBoundDrift, 0.f, -SignalConfiguration.InnerBoundDrift, 1.f)}, {{-SignalConfiguration.InnerBoundDrift, SignalConfiguration.InnerBoundDrift}, std::make_shared>(1.f, 0.f)}, {{SignalConfiguration.InnerBoundDrift, SignalConfiguration.OuterBoundDrift}, std::make_shared>( SignalConfiguration.InnerBoundDrift, 1.f, SignalConfiguration.OuterBoundDrift, 0.f)}, }, 0)); // // Create following function(s) which shall give information whether a // signal is drifting. // // ____________ ____________ // \ / // \ / // \__________/ // // SignalIsDriftingFunctions.emplace_back(new PartialFunction( { {{-SignalConfiguration.OuterBoundDrift, -SignalConfiguration.InnerBoundDrift}, std::make_shared>( -SignalConfiguration.OuterBoundDrift, 1.f, -SignalConfiguration.InnerBoundDrift, 0.f)}, {{-SignalConfiguration.InnerBoundDrift, SignalConfiguration.InnerBoundDrift}, std::make_shared>(0.f, 0.f)}, {{SignalConfiguration.InnerBoundDrift, SignalConfiguration.OuterBoundDrift}, std::make_shared>( SignalConfiguration.InnerBoundDrift, 0.f, SignalConfiguration.OuterBoundDrift, 1.f)}, }, 1)); // // Create following function(s) which shall give information how many // history samples match another sample. // // ____________ // / // / // __________/ // NumOfSamplesMatchFunctions.emplace_back(new StepFunction( 1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepUp)); // // Create following function(s) which shall give information how many // history samples mismatch another sample. // // ____________ // \ - // \ - // \__________ + // \ + // \__________ // NumOfSamplesMismatchFunctions.emplace_back(new StepFunction( 1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepDown)); // // Create following function(s) which shall give information how good all // samples in a state match each other. // // ____________ // / \ - // / \ - // __________/ \__________ + // / \ + // __________/ \__________ // // SampleValidFunctions.emplace_back(new PartialFunction( { {{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound}, std::make_shared>( -SignalConfiguration.OuterBound, 0.f, -SignalConfiguration.InnerBound, 1.f)}, {{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound}, std::make_shared>(1.f, 0.f)}, {{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound}, std::make_shared>( SignalConfiguration.InnerBound, 1.f, SignalConfiguration.OuterBound, 0.f)}, }, 0)); // // Create following function(s) which shall give information how good all // samples in a state mismatch each other. // // ____________ ____________ // \ / // \ / // \__________/ // // SampleInvalidFunctions.emplace_back(new PartialFunction( { {{-SignalConfiguration.OuterBound, -SignalConfiguration.InnerBound}, std::make_shared>( -SignalConfiguration.OuterBound, 1.f, -SignalConfiguration.InnerBound, 0.f)}, {{-SignalConfiguration.InnerBound, SignalConfiguration.InnerBound}, std::make_shared>(0.f, 0.f)}, {{SignalConfiguration.InnerBound, SignalConfiguration.OuterBound}, std::make_shared>( SignalConfiguration.InnerBound, 0.f, SignalConfiguration.OuterBound, 1.f)}, }, 1)); // // Create following function(s) which shall give information how many // history samples match each other. // // ____________ // / // / // __________/ // NumOfSamplesValidFunctions.emplace_back(new StepFunction( 1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepUp)); // // Create following function(s) which shall give information how many // history samples mismatch each other. // // ____________ // \ - // \ - // \__________ + // \ + // \__________ // NumOfSamplesInvalidFunctions.emplace_back(new StepFunction( 1.0f / SignalConfiguration.SampleHistorySize, StepDirection::StepDown)); // // Create SignalStateDetector functionality // SignalStateDetectors.emplace_back( new SignalStateDetector( SignalConfiguration.Output ? SignalProperties::OUTPUT : SignalProperties::INPUT, std::numeric_limits::max(), SampleMatchesFunctions.back(), SampleMismatchesFunctions.back(), NumOfSamplesMatchFunctions.back(), NumOfSamplesMismatchFunctions.back(), SampleValidFunctions.back(), SampleInvalidFunctions.back(), NumOfSamplesValidFunctions.back(), NumOfSamplesInvalidFunctions.back(), SignalIsDriftingFunctions.back(), SignalIsStableFunctions.back(), SignalConfiguration.SampleHistorySize, SignalConfiguration.DABSize, SignalConfiguration.DABHistorySize)); // // Create low-level application agents // SignalStateDetectorAgents.push_back(createSignalStateDetectorAgent( AppCCAM, SignalConfiguration.Name, SignalStateDetectors.back())); AppCCAM->setExecutionPolicy( SignalStateDetectorAgents.back(), AppExecutionPolicy::decimation(AppConfig.DownsamplingRate)); // // Connect sensors to low-level agents. // LOG_INFO("Connect sensors to their corresponding low-level agents."); AppCCAM->connectSensor(SignalStateDetectorAgents.back(), 0, Sensors.back(), SignalConfiguration.Name + "_Sensor ->" + SignalConfiguration.Name + "_SignalStateDetector_Agent-Channel"); AppCCAM->connectAgents( SystemStateDetectorAgent, SignalStateDetectors.size() - 1, SignalStateDetectorAgents.back(), SignalConfiguration.Name + "_SignalStateDetector_Agent->SystemStateDetector_Agent_Channel"); } // // For simulation output, create a logger agent writing the output of the // high-level agent into a CSV file. // LOG_INFO("Create a logger agent."); // Create CSV writer. std::ofstream OutputCSV(AppConfig.OutputFilePath); for (auto SignalConfiguration : AppConfig.SignalConfigurations) { OutputCSV << SignalConfiguration.Name + ","; } OutputCSV << "StateID,"; OutputCSV << "Confidence State Valid,"; OutputCSV << "Confidence State Invalid,"; OutputCSV << "Confidence Inputs Matching,"; OutputCSV << "Confidence Outputs Matching,"; OutputCSV << "Confidence Inputs Mismatching,"; OutputCSV << "Confidence Outputs Mismatching,"; OutputCSV << "State Condition,"; OutputCSV << "Confidence System Functioning,"; OutputCSV << "Confidence System Malfunctioning,"; OutputCSV << "Overall Confidence,"; OutputCSV << "\n"; // The agent writes each new input value into a CSV file and produces // nothing. using Input = std::pair; using Result = Optional>; using Handler = std::function; std::string Name = "Logger Agent"; AgentHandle LoggerAgent = AppCCAM->createAgent( "Logger Agent", Handler([&OutputCSV](Input I) -> Result { const SystemStateTuple &T = I.first; OutputCSV << std::get<0>( static_cast &>(T)) << std::endl; return Result(); })); // // Connect the high-level agent to the logger agent. // LOG_INFO("Connect the high-level agent to the logger agent."); AppCCAM->connectAgents(LoggerAgent, 0, SystemStateDetectorAgent, "SystemStateDetector Channel"); // // Only log if the SystemStateDetector actually ran // AppCCAM->setExecutionPolicy(LoggerAgent, AppExecutionPolicy::awaitAll({0})); // // Do simulation. // LOG_INFO("Setting up and performing simulation."); // // Initialize application for simulation. // AppCCAM->initializeSimulation(); // // Open CSV files and register them for their corresponding sensors. // // Make sure DataFiles will not change capacity while adding elements to it. // Changing capacity moves elements away, which invalidates references // captured by CSVIterator. DataFiles.reserve(AppConfig.SignalConfigurations.size()); uint32_t i = 0; for (auto SignalConfiguration : AppConfig.SignalConfigurations) { - DataFiles.emplace_back(SignalConfiguration.InputPath); - if (!DataFiles.at(i)) { - LOG_ERROR_STREAM << "Cannot open Input File \"" - << SignalConfiguration.InputPath << "\" for Signal \"" - << SignalConfiguration.Name << "\"" << std::endl; - return 3; - } - AppCCAM->registerSensorValues(Sensors.at(i), - csv::CSVIterator(DataFiles.at(i)), - csv::CSVIterator()); + switch (SignalConfiguration.DataInterfaceType) { + case DataInterfaceTypes::CSV: + + DataFiles.emplace_back(SignalConfiguration.InputPath); + if (!DataFiles.at(i)) { + LOG_ERROR_STREAM << "Cannot open Input File \"" + << SignalConfiguration.InputPath << "\" for Signal \"" + << SignalConfiguration.Name << "\"" << std::endl; + return 3; + } + + AppCCAM->registerSensorValues(Sensors.at(i), + csv::CSVIterator(DataFiles.at(i)), + csv::CSVIterator()); + + break; + case DataInterfaceTypes::MQTT: + AppCCAM->registerSensorValues( + Sensors.at(i), + MQTT::MQTTIterator(SignalConfiguration.MQTTTopic), + MQTT::MQTTIterator()) break; + } i++; } // // Start simulation. // AppCCAM->simulate(AppConfig.NumberOfSimulationCycles); return 0; } diff --git a/apps/ccam/configuration.h b/apps/ccam/configuration.h index f66f04c..3058baa 100644 --- a/apps/ccam/configuration.h +++ b/apps/ccam/configuration.h @@ -1,87 +1,97 @@ #ifndef CONFIGURATION_H #define CONFIGURATION_H // clang-tidy off // clang-format off #include "nlohmann/json.hpp" // clang-format on // clang-tidy on #include "rosa/config/version.h" #include "rosa/app/Application.hpp" #include using namespace rosa; using nlohmann::json; +enum DataInterfaceTypes { CSV, MQTT }; + struct SignalConfiguration { std::string Name; std::string InputPath; + std::string MQTTTopic; + DataInterfaceTypes DataInterfaceType; bool Output; float InnerBound; float OuterBound; float InnerBoundDrift; float OuterBoundDrift; uint32_t SampleHistorySize; uint32_t DABSize; uint32_t DABHistorySize; }; struct AppConfiguration { std::string OutputFilePath; uint32_t BrokenCounter; uint32_t NumberOfSimulationCycles; uint32_t DownsamplingRate; std::vector SignalConfigurations; }; void from_json(const json &J, SignalConfiguration &SC) { J.at("Name").get_to(SC.Name); - J.at("InputPath").get_to(SC.InputPath); + if (J.contains("InputPath")) { + J.at("InputPath").get_to(SC.InputPath); + SC.DataInterfaceType = DataInterfaceTypes::CSV; + } else if (J.contains("MQTTTopic")) { + J.at("MQTTTopic").get_to(SC.MQTTTopic); + SC.DataInterfaceType = DataInterfaceTypes::MQTT; + } J.at("Output").get_to(SC.Output); J.at("InnerBound").get_to(SC.InnerBound); J.at("OuterBound").get_to(SC.OuterBound); J.at("InnerBoundDrift").get_to(SC.InnerBoundDrift); J.at("OuterBoundDrift").get_to(SC.OuterBoundDrift); J.at("SampleHistorySize").get_to(SC.SampleHistorySize); J.at("DABSize").get_to(SC.DABSize); J.at("DABHistorySize").get_to(SC.DABHistorySize); } void from_json(const json &J, AppConfiguration &AC) { J.at("OutputFilePath").get_to(AC.OutputFilePath); J.at("BrokenCounter").get_to(AC.BrokenCounter); J.at("NumberOfSimulationCycles").get_to(AC.NumberOfSimulationCycles); J.at("DownsamplingRate").get_to(AC.DownsamplingRate); J.at("SignalConfigurations").get_to(AC.SignalConfigurations); } AppConfiguration AppConfig; bool readConfigFile(std::string ConfigPath) { LOG_INFO("READING CONFIG FILE"); LOG_INFO_STREAM << "Looking for config file at \"" << ConfigPath << "\"\n"; std::ifstream ConfigFile; ConfigFile.open(ConfigPath); if (!ConfigFile) { LOG_ERROR("Unable to open config file"); return false; } json ConfigObj; ConfigFile >> ConfigObj; LOG_INFO_STREAM << "Read JSON file as \"" << ConfigObj << "\"\n"; try { ConfigObj.get_to(AppConfig); } catch (nlohmann::detail::type_error ex) { LOG_ERROR("Misformatted Config File"); return false; } return true; } #endif // CONFIGURATION_H diff --git a/apps/ccam/statehandlerutils.h b/apps/ccam/statehandlerutils.h index 3542842..4d87142 100644 --- a/apps/ccam/statehandlerutils.h +++ b/apps/ccam/statehandlerutils.h @@ -1,229 +1,274 @@ #ifndef STATEHANDLERUTILS_H #define STATEHANDLERUTILS_H #include "rosa/agent/Abstraction.hpp" #include "rosa/agent/Confidence.hpp" #include "rosa/agent/FunctionAbstractions.hpp" #include #include #include #include #include "rosa/config/version.h" #include "rosa/agent/SignalStateDetector.hpp" #include "rosa/agent/SystemStateDetector.hpp" #include "rosa/app/Application.hpp" #include "rosa/support/csv/CSVReader.hpp" #include "rosa/support/csv/CSVWriter.hpp" #include #include #include #include using namespace rosa; using namespace rosa::agent; using namespace rosa::app; using namespace rosa::terminal; // For the convinience to write a shorter data type name using SignalStateTuple = AppTuple; AgentHandle createSignalStateDetectorAgent( std::unique_ptr &C, const std::string &Name, std::shared_ptr< SignalStateDetector> SigSD) { using Input = std::pair, bool>; using Result = Optional; using Handler = std::function; return C->createAgent( Name, Handler([&, Name, SigSD](Input I) -> Result { LOG_INFO_STREAM << "\n******\n" << Name << " " << (I.second ? "" : "") << " value: " << std::get<0>( static_cast &>(I.first)) << "\n******\n"; auto StateInfo = SigSD->detectSignalState( std::get<0>(static_cast &>(I.first))); if (I.second) { SignalStateTuple Res = { std::get<0>(static_cast &>(I.first)), StateInfo.StateID, StateInfo.SignalProperty, StateInfo.ConfidenceOfMatchingState, StateInfo.ConfidenceOfMismatchingState, StateInfo.ConfidenceStateIsValid, StateInfo.ConfidenceStateIsInvalid, StateInfo.ConfidenceStateIsStable, StateInfo.ConfidenceStateIsDrifting, StateInfo.StateCondition, StateInfo.NumberOfInsertedSamplesAfterEntrance, static_cast( (StateInfo.StateIsValid ? 4 : 0) + (StateInfo.StateJustGotValid ? 2 : 0) + (StateInfo.StateIsValidAfterReentrance ? 1 : 0))}; return Result(Res); } return Result(); })); } // System State using SystemStateTuple = AppTuple; template struct Handler_helper; template struct function_helper { static_assert(std::conjunction_v...>, "All types need to be identical"); static B function(A valA, As... valAs) { std::vector ar({valA, valAs...}); return func()(ar); } }; template struct Handler_helper<0, ret, functype, typeA, B...> { using handler = function_helper; }; template struct Handler_helper { using handler = typename Handler_helper, B...>::handler; }; template using Handler = typename Handler_helper::handler; // TODO: Change it from global to local variable if possible std::shared_ptr< SystemStateDetector> SysSD; template struct function { ret operator()(A a) { std::vector> SignalStateInfos; std::stringstream OutString; for (auto _SignalStateTuple : a) { // convert tuple to info struct out.push_back({}); OutString << std::get<0>(_SignalStateTuple.first) << ","; SignalStateInformation Info; Info.StateID = std::get<1>(_SignalStateTuple.first); Info.SignalProperty = static_cast(std::get<2>(_SignalStateTuple.first)); Info.ConfidenceOfMatchingState = std::get<3>(_SignalStateTuple.first); Info.ConfidenceOfMismatchingState = std::get<4>(_SignalStateTuple.first); Info.ConfidenceStateIsValid = std::get<5>(_SignalStateTuple.first); Info.ConfidenceStateIsInvalid = std::get<6>(_SignalStateTuple.first); Info.ConfidenceStateIsStable = std::get<7>(_SignalStateTuple.first); Info.ConfidenceStateIsDrifting = std::get<8>(_SignalStateTuple.first); Info.StateCondition = static_cast(std::get<9>(_SignalStateTuple.first)); Info.NumberOfInsertedSamplesAfterEntrance = std::get<10>(_SignalStateTuple.first); Info.StateIsValid = (std::get<11>(_SignalStateTuple.first) & 4) > 0; Info.StateJustGotValid = (std::get<11>(_SignalStateTuple.first) & 2) > 0; Info.StateIsValidAfterReentrance = (std::get<11>(_SignalStateTuple.first) & 1) > 0; SignalStateInfos.push_back(Info); } SystemStateInformation SystemStateInfo = SysSD->detectSystemState(SignalStateInfos); OutString << SystemStateInfo.StateID << ","; OutString << SystemStateInfo.ConfidenceStateIsValid << ","; OutString << SystemStateInfo.ConfidenceStateIsInvalid << ","; OutString << SystemStateInfo.ConfidenceOfInputsMatchingState << ","; OutString << SystemStateInfo.ConfidenceOfInputsMismatchingState << ","; OutString << SystemStateInfo.ConfidenceOfOutputsMatchingState << ","; OutString << SystemStateInfo.ConfidenceOfOutputsMismatchingState << ","; OutString << SystemStateInfo.StateCondition << ","; OutString << SystemStateInfo.ConfidenceSystemIsFunctioning << ","; OutString << SystemStateInfo.ConfidenceSystemIsMalfunctioning << ","; OutString << SystemStateInfo.ConfidenceOfAllDecisions << ","; return ret(std::make_tuple(OutString.str())); } }; using arr = std::vector>; template AgentHandle createSystemStateDetectorAgent( std::unique_ptr &C, const std::string &Name, std::shared_ptr> BrokenDelayFunction, std::shared_ptr> OkDelayFunction) { LOG_TRACE("Creating fixed SystemStateDetectorAgent"); using Input = SignalStateTuple; using Result = Optional; std::shared_ptr< SystemStateDetector> _SysSD( new SystemStateDetector( std::numeric_limits::max(), NumOfSlaves, BrokenDelayFunction, OkDelayFunction)); SysSD = _SysSD; auto HandlerFunction = Handler, arr>, Input>::function; return C->createAgent(Name, std::function(HandlerFunction)); } AgentHandle createSystemStateDetectorAgent( std::unique_ptr &C, const std::string &Name, size_t NumOfSlaves, std::shared_ptr> BrokenDelayFunction, std::shared_ptr> OkDelayFunction) { LOG_TRACE("Creating dynamic SystemStateDetectorAgent"); switch (NumOfSlaves) { // clang-format off case 2: return createSystemStateDetectorAgent< 2>(C, Name, BrokenDelayFunction, OkDelayFunction); case 3: return createSystemStateDetectorAgent< 3>(C, Name, BrokenDelayFunction, OkDelayFunction); case 4: return createSystemStateDetectorAgent< 4>(C, Name, BrokenDelayFunction, OkDelayFunction); case 5: return createSystemStateDetectorAgent< 5>(C, Name, BrokenDelayFunction, OkDelayFunction); case 6: return createSystemStateDetectorAgent< 6>(C, Name, BrokenDelayFunction, OkDelayFunction); case 7: return createSystemStateDetectorAgent< 7>(C, Name, BrokenDelayFunction, OkDelayFunction); case 8: return createSystemStateDetectorAgent< 8>(C, Name, BrokenDelayFunction, OkDelayFunction); case 9: return createSystemStateDetectorAgent< 9>(C, Name, BrokenDelayFunction, OkDelayFunction); case 10: return createSystemStateDetectorAgent<10>(C, Name, BrokenDelayFunction, OkDelayFunction); case 11: return createSystemStateDetectorAgent<11>(C, Name, BrokenDelayFunction, OkDelayFunction); case 12: return createSystemStateDetectorAgent<12>(C, Name, BrokenDelayFunction, OkDelayFunction); case 13: return createSystemStateDetectorAgent<13>(C, Name, BrokenDelayFunction, OkDelayFunction); case 14: return createSystemStateDetectorAgent<14>(C, Name, BrokenDelayFunction, OkDelayFunction); case 15: return createSystemStateDetectorAgent<15>(C, Name, BrokenDelayFunction, OkDelayFunction); case 16: return createSystemStateDetectorAgent<16>(C, Name, BrokenDelayFunction, OkDelayFunction); case 17: return createSystemStateDetectorAgent<17>(C, Name, BrokenDelayFunction, OkDelayFunction); case 18: return createSystemStateDetectorAgent<18>(C, Name, BrokenDelayFunction, OkDelayFunction); case 19: return createSystemStateDetectorAgent<19>(C, Name, BrokenDelayFunction, OkDelayFunction); case 20: return createSystemStateDetectorAgent<20>(C, Name, BrokenDelayFunction, OkDelayFunction); case 21: return createSystemStateDetectorAgent<21>(C, Name, BrokenDelayFunction, OkDelayFunction); case 22: return createSystemStateDetectorAgent<22>(C, Name, BrokenDelayFunction, OkDelayFunction); case 23: return createSystemStateDetectorAgent<23>(C, Name, BrokenDelayFunction, OkDelayFunction); case 24: return createSystemStateDetectorAgent<24>(C, Name, BrokenDelayFunction, OkDelayFunction); case 25: return createSystemStateDetectorAgent<25>(C, Name, BrokenDelayFunction, OkDelayFunction); case 1: default: return createSystemStateDetectorAgent<1>(C, Name, BrokenDelayFunction, OkDelayFunction); // clang-format on } } + +template +AgentHandle createMQTTSensor(std::string MQTTTopic) { + + using Input = void; + + using Result = Optional; + using Handler = std::function; + + return C->createAgent( + Name, Handler([&, Name, SigSD](Input I) -> Result { + LOG_INFO_STREAM << "\n******\n" + << Name << " " << (I.second ? "" : "") + << " value: " + << std::get<0>( + static_cast &>(I.first)) + << "\n******\n"; + + auto StateInfo = SigSD->detectSignalState( + std::get<0>(static_cast &>(I.first))); + + if (I.second) { + SignalStateTuple Res = { + std::get<0>(static_cast &>(I.first)), + StateInfo.StateID, + StateInfo.SignalProperty, + StateInfo.ConfidenceOfMatchingState, + StateInfo.ConfidenceOfMismatchingState, + StateInfo.ConfidenceStateIsValid, + StateInfo.ConfidenceStateIsInvalid, + StateInfo.ConfidenceStateIsStable, + StateInfo.ConfidenceStateIsDrifting, + StateInfo.StateCondition, + StateInfo.NumberOfInsertedSamplesAfterEntrance, + static_cast( + (StateInfo.StateIsValid ? 4 : 0) + + (StateInfo.StateJustGotValid ? 2 : 0) + + (StateInfo.StateIsValidAfterReentrance ? 1 : 0))}; + + return Result(Res); + } + return Result(); + })); +} + #endif // STATEHANDLERUTILS_H diff --git a/include/rosa/agent/SignalState.hpp b/include/rosa/agent/SignalState.hpp index 5ba84b4..76b4d8e 100644 --- a/include/rosa/agent/SignalState.hpp +++ b/include/rosa/agent/SignalState.hpp @@ -1,647 +1,649 @@ //===-- rosa/agent/SignalState.hpp ------------------------------*- C++ -*-===// // // The RoSA Framework // //===----------------------------------------------------------------------===// /// /// \file rosa/agent/SignalState.hpp /// /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at) /// /// \date 2019 /// /// \brief Definition of *signal state* *functionality*. /// //===----------------------------------------------------------------------===// #ifndef ROSA_AGENT_SIGNALSTATE_HPP #define ROSA_AGENT_SIGNALSTATE_HPP #include "rosa/agent/FunctionAbstractions.hpp" #include "rosa/agent/Functionality.h" #include "rosa/agent/History.hpp" #include "rosa/agent/State.hpp" #include "rosa/support/math.hpp" namespace rosa { namespace agent { /// Signal properties defining the properties of the signal which is monitored /// by \c rosa::agent::SignalStateDetector and is saved in \c /// rosa::agent::SignalStateInformation. enum SignalProperties : uint8_t { INPUT = 0, ///< The signal is an input signal OUTPUT = 1 ///< The signal is an output signal }; /// TODO: write description template struct SignalStateInformation : StateInformation { // Make sure the actual type arguments are matching our expectations. STATIC_ASSERT((std::is_arithmetic::value), "confidence type is not to arithmetic"); /// ConfidenceOfMatchingState is the confidence how good the new sample /// matches the state. CONFDATATYPE ConfidenceOfMatchingState; /// ConfidenceOfMatchingState is the confidence how bad the new sample /// matches the state. CONFDATATYPE ConfidenceOfMismatchingState; /// The SignalProperty saves whether the monitored signal is an input our /// output signal. SignalProperties SignalProperty; /// The SignalStateIsValid saves the number of samples which have been /// inserted into the state after entering it. uint32_t NumberOfInsertedSamplesAfterEntrance; public: SignalStateInformation(unsigned int SignalStateID, SignalProperties _SignalProperty) { this->StateID = SignalStateID; this->SignalProperty = _SignalProperty; this->StateCondition = StateConditions::UNKNOWN; this->NumberOfInsertedSamplesAfterEntrance = 0; this->StateIsValid = false; this->StateJustGotValid = false; this->StateIsValidAfterReentrance = false; this->ConfidenceStateIsValid = 0; this->ConfidenceStateIsInvalid = 0; this->ConfidenceStateIsStable = 0; this->ConfidenceStateIsDrifting = 0; } SignalStateInformation() = default; }; /// \tparam INDATATYPE type of input data, \tparam CONFDATATYPE type of /// data in that the confidence values are given, \tparam PROCDATATYPE type of /// the relative distance and the type of data in which DABs are saved. template class SignalState : public Functionality { // Make sure the actual type arguments are matching our expectations. STATIC_ASSERT((std::is_arithmetic::value), "input data type not arithmetic"); STATIC_ASSERT((std::is_arithmetic::value), "confidence data type is not to arithmetic"); STATIC_ASSERT( (std::is_arithmetic::value), "process data type (DAB and Relative Distance) is not to arithmetic"); public: // For the convinience to write a shorter data type name using PartFuncReference = PartialFunction &; // using PartFuncReference2 = ; using StepFuncReference = StepFunction &; private: /// SignalStateInfo is a struct of SignalStateInformation that contains /// information about the current signal state. SignalStateInformation SignalStateInfo; /// The FuzzyFunctionSampleMatches is the fuzzy function that gives the /// confidence how good the new sample matches another sample in the sample /// history. PartFuncReference FuzzyFunctionSampleMatches; /// The FuzzyFunctionSampleMismatches is the fuzzy function that gives the /// confidence how bad the new sample matches another sample in the sample /// history. PartFuncReference FuzzyFunctionSampleMismatches; /// The FuzzyFunctionNumOfSamplesMatches is the fuzzy function that gives the /// confidence how many samples from the sampe history match the new sample. StepFuncReference FuzzyFunctionNumOfSamplesMatches; /// The FuzzyFunctionNumOfSamplesMismatches is the fuzzy function that gives /// the confidence how many samples from the sampe history mismatch the new /// sample. StepFuncReference FuzzyFunctionNumOfSamplesMismatches; /// The FuzzyFunctionSampleValid is the fuzzy function that gives the /// confidence how good one matches another sample in the sample /// history. This is done to evaluate whether a state is valid. PartFuncReference FuzzyFunctionSampleValid; /// The FuzzyFunctionSampleInvalid is the fuzzy function that gives the /// confidence how bad one sample matches another sample in the sample /// history. This is done to evaluate whether a state is invalid. PartFuncReference FuzzyFunctionSampleInvalid; /// The FuzzyFunctionNumOfSamplesValid is the fuzzy function that gives the /// confidence how many samples from the sample history match another sample. /// This is done to evaluate whether a state is valid. StepFuncReference FuzzyFunctionNumOfSamplesValid; /// The FuzzyFunctionNumOfSamplesInvalid is the fuzzy function that gives /// the confidence how many samples from the sample history mismatch another /// sample. This is done to evaluate whether a state is invalid. StepFuncReference FuzzyFunctionNumOfSamplesInvalid; /// The FuzzyFunctionSignalIsDrifting is the fuzzy function that gives the /// confidence how likely it is that the signal (resp. the state of a signal) /// is drifting. PartFuncReference FuzzyFunctionSignalIsDrifting; /// The FuzzyFunctionSignalIsStable is the fuzzy function that gives the /// confidence how likely it is that the signal (resp. the state of a signal) /// is stable (not drifting). PartFuncReference FuzzyFunctionSignalIsStable; /// TODO: description - PartialFunction &FuzzyFunctionSignalConditionLookBack; + // PartialFunction &FuzzyFunctionSignalConditionLookBack; /// TODO: description - PartialFunction &FuzzyFunctionSignalConditionHistoryDesicion; + // PartialFunction + // &FuzzyFunctionSignalConditionHistoryDesicion; /// TODO: description - uint32_t DriftLookbackRange; + // uint32_t DriftLookbackRange; /// SampleHistory is a history in that the last sample values are stored. DynamicLengthHistory SampleHistory; /// DAB is a (usually) small history of the last sample values of which a /// average is calculated if the DAB is full. DynamicLengthHistory DAB; /// DABHistory is a history in that the last DABs (to be exact, the averages /// of the last DABs) are stored. DynamicLengthHistory DABHistory; /// LowestConfidenceMatchingHistory is a history in that the lowest confidence /// for the current sample matches all history samples are saved. DynamicLengthHistory LowestConfidenceMatchingHistory; /// HighestConfidenceMatchingHistory is a history in that the highest /// confidence for the current sample matches all history samples are saved. DynamicLengthHistory HighestConfidenceMismatchingHistory; /// TempConfidenceMatching is the confidence how good a sample matches the /// state. However, the value of this variable is only needed temporarly. CONFDATATYPE TempConfidenceMatching = 0; /// TempConfidenceMatching is the confidence how bad a sample matches the /// state. However, the value of this variable is only needed temporarly. CONFDATATYPE TempConfidenceMismatching = 0; public: /// Creates an instance by setting all parameters /// \param SignalStateID The Id of the SignalStateinfo \c /// SignalStateInformation. /// /// \param FuzzyFunctionSampleMatches The FuzzyFunctionSampleMatches is the /// fuzzy function that gives the confidence how good the new sample matches /// another sample in the sample history. /// /// \param FuzzyFunctionSampleMismatches The FuzzyFunctionSampleMismatches is /// the fuzzy function that gives the confidence how bad the new sample /// matches another sample in the sample history. /// /// \param FuzzyFunctionNumOfSamplesMatches The /// FuzzyFunctionNumOfSamplesMatches is the fuzzy function that gives the /// confidence how many samples from the sampe history match the new sample. /// /// \param FuzzyFunctionNumOfSamplesMismatches The /// FuzzyFunctionNumOfSamplesMismatches is the fuzzy function that gives the /// confidence how many samples from the sampe history mismatch the new /// sample. /// /// \param FuzzyFunctionSignalIsDrifting The FuzzyFunctionSignalIsDrifting is /// the fuzzy function that gives the confidence how likely it is that the /// signal (resp. the state of a signal) is drifting. /// /// \param FuzzyFunctionSignalIsStable The FuzzyFunctionSignalIsStable is the /// fuzzy function that gives the confidence how likely it is that the signal /// (resp. the state of a signal) is stable (not drifting). /// /// \param SampleHistorySize Size of the Sample History \c /// DynamicLengthHistory . SampleHistory is a history in that the last sample /// values are stored. /// /// \param DABSize Size of DAB \c DynamicLengthHistory . DAB is a (usually) /// small history of the last sample values of which a average is calculated /// if the DAB is full. /// /// \param DABHistorySize Size of the DABHistory \c DynamicLengthHistory . /// DABHistory is a history in that the last DABs (to be exact, the averages /// of the last DABs) are stored. /// SignalState( uint32_t SignalStateID, SignalProperties SignalProperty, uint32_t SampleHistorySize, uint32_t DABSize, uint32_t DABHistorySize, PartFuncReference FuzzyFunctionSampleMatches, PartFuncReference FuzzyFunctionSampleMismatches, StepFuncReference FuzzyFunctionNumOfSamplesMatches, StepFuncReference FuzzyFunctionNumOfSamplesMismatches, PartFuncReference FuzzyFunctionSampleValid, PartFuncReference FuzzyFunctionSampleInvalid, StepFuncReference FuzzyFunctionNumOfSamplesValid, StepFuncReference FuzzyFunctionNumOfSamplesInvalid, PartFuncReference FuzzyFunctionSignalIsDrifting, - PartFuncReference FuzzyFunctionSignalIsStable, - PartialFunction &FuzzyFunctionSignalConditionLookBack, - PartialFunction - &FuzzyFunctionSignalConditionHistoryDesicion, - uint32_t DriftLookbackRange) noexcept + PartFuncReference FuzzyFunctionSignalIsStable //, + // PartialFunction &FuzzyFunctionSignalConditionLookBack, + // PartialFunction + // &FuzzyFunctionSignalConditionHistoryDesicion, + // uint32_t DriftLookbackRange + ) noexcept : SignalStateInfo{SignalStateID, SignalProperty}, FuzzyFunctionSampleMatches(FuzzyFunctionSampleMatches), FuzzyFunctionSampleMismatches(FuzzyFunctionSampleMismatches), FuzzyFunctionNumOfSamplesMatches(FuzzyFunctionNumOfSamplesMatches), FuzzyFunctionNumOfSamplesMismatches( FuzzyFunctionNumOfSamplesMismatches), FuzzyFunctionSampleValid(FuzzyFunctionSampleValid), FuzzyFunctionSampleInvalid(FuzzyFunctionSampleInvalid), FuzzyFunctionNumOfSamplesValid(FuzzyFunctionNumOfSamplesValid), FuzzyFunctionNumOfSamplesInvalid(FuzzyFunctionNumOfSamplesInvalid), FuzzyFunctionSignalIsDrifting(FuzzyFunctionSignalIsDrifting), FuzzyFunctionSignalIsStable(FuzzyFunctionSignalIsStable), - FuzzyFunctionSignalConditionLookBack( - FuzzyFunctionSignalConditionLookBack), - FuzzyFunctionSignalConditionHistoryDesicion( - FuzzyFunctionSignalConditionHistoryDesicion), - DriftLookbackRange(DriftLookbackRange), + // FuzzyFunctionSignalConditionLookBack( + // FuzzyFunctionSignalConditionLookBack), + // FuzzyFunctionSignalConditionHistoryDesicion( + // FuzzyFunctionSignalConditionHistoryDesicion), + // DriftLookbackRange(DriftLookbackRange), SampleHistory(SampleHistorySize), DAB(DABSize), DABHistory(DABHistorySize), LowestConfidenceMatchingHistory(SampleHistorySize), HighestConfidenceMismatchingHistory(SampleHistorySize) {} /// Destroys \p this object. ~SignalState(void) = default; void leaveSignalState(void) noexcept { DAB.clear(); SignalStateInfo.NumberOfInsertedSamplesAfterEntrance = 0; SignalStateInfo.StateIsValidAfterReentrance = false; } SignalStateInformation insertSample(INDATATYPE Sample) noexcept { SignalStateInfo.NumberOfInsertedSamplesAfterEntrance++; validateSignalState(Sample); SampleHistory.addEntry(Sample); DAB.addEntry(Sample); if (DAB.full()) { // Experiment -> exchanged next line with the folowings // PROCDATATYPE AvgOfDAB = DAB.template average(); // TODO: make soring inside of median // TODO: make better outlier removal! std::sort(DAB.begin(), DAB.end()); // DAB.erase(DAB.begin(), DAB.begin() + 1); // DAB.erase(DAB.end() - 1, DAB.end()); // PROCDATATYPE AvgOfDAB = DAB.template median(); PROCDATATYPE AvgOfDAB = DAB.template average(); DABHistory.addEntry(AvgOfDAB); DAB.clear(); } FuzzyFunctionNumOfSamplesMatches.setRightLimit( static_cast(SampleHistory.numberOfEntries())); FuzzyFunctionNumOfSamplesMismatches.setRightLimit( static_cast(SampleHistory.numberOfEntries())); checkSignalStability(); SignalStateInfo.ConfidenceOfMatchingState = TempConfidenceMatching; SignalStateInfo.ConfidenceOfMismatchingState = TempConfidenceMismatching; return SignalStateInfo; } /// Gives the confidence how likely the new sample matches the signal state. /// /// \param Sample is the actual sample of the observed signal. /// /// \return the confidence of the new sample is matching the signal state. CONFDATATYPE confidenceSampleMatchesSignalState(INDATATYPE Sample) noexcept { CONFDATATYPE ConfidenceOfBestCase = 0; DynamicLengthHistory RelativeDistanceHistory(SampleHistory.maxLength()); // Calculate distances to all history samples. for (auto &HistorySample : SampleHistory) { PROCDATATYPE RelativeDistance = relativeDistance(Sample, HistorySample); RelativeDistanceHistory.addEntry(RelativeDistance); } // Sort all calculated distances so that the lowest distance (will get the // highest confidence) is at the beginning. RelativeDistanceHistory.sortAscending(); CONFDATATYPE ConfidenceOfWorstFittingSample = 1; // Case 1 means that one (the best fitting) sample of the history is // compared with the new sample. Case 2 means the two best history samples // are compared with the new sample. And so on. // TODO (future): to accelerate . don't start with 1 start with some higher // number because a low number (i guess lower than 5) will definetely lead // to a low confidence. except the history is not full. // Case 1 means that one (the best fitting) sample of the history is // compared with the new sample. Case 2 means the two best history samples // are compared with the new sample. And so on. for (uint32_t Case = 0; Case < RelativeDistanceHistory.numberOfEntries(); Case++) { CONFDATATYPE ConfidenceFromRelativeDistance; if (std::isinf(RelativeDistanceHistory[Case])) { // TODO (future): if fuzzy is defined in a way that infinity is not 0 it // would be a problem. ConfidenceFromRelativeDistance = 0; } else { ConfidenceFromRelativeDistance = FuzzyFunctionSampleMatches(RelativeDistanceHistory[Case]); } ConfidenceOfWorstFittingSample = fuzzyAND(ConfidenceOfWorstFittingSample, ConfidenceFromRelativeDistance); ConfidenceOfBestCase = fuzzyOR(ConfidenceOfBestCase, fuzzyAND(ConfidenceOfWorstFittingSample, FuzzyFunctionNumOfSamplesMatches( static_cast(Case) + 1))); } TempConfidenceMatching = ConfidenceOfBestCase; return ConfidenceOfBestCase; } /// Gives the confidence how likely the new sample mismatches the signal /// state. /// /// \param Sample is the actual sample of the observed signal. /// /// \return the confidence of the new sample is mismatching the signal state. CONFDATATYPE confidenceSampleMismatchesSignalState(INDATATYPE Sample) noexcept { float ConfidenceOfWorstCase = 1; DynamicLengthHistory RelativeDistanceHistory(SampleHistory.maxLength()); // Calculate distances to all history samples. for (auto &HistorySample : SampleHistory) { RelativeDistanceHistory.addEntry( relativeDistance(Sample, HistorySample)); } // Sort all calculated distances so that the highest distance (will get the // lowest confidence) is at the beginning. RelativeDistanceHistory.sortDescending(); CONFDATATYPE ConfidenceOfBestFittingSample = 0; // TODO (future): to accelerate -> don't go until end. Confidences will only // get higher. See comment in "CONFDATATYPE // confidenceSampleMatchesSignalState(INDATATYPE Sample)". // Case 1 means that one (the worst fitting) sample of the history is // compared with the new sample. Case 2 means the two worst history samples // are compared with the new sample. And so on. for (uint32_t Case = 0; Case < RelativeDistanceHistory.numberOfEntries(); Case++) { CONFDATATYPE ConfidenceFromRelativeDistance; if (std::isinf(RelativeDistanceHistory[Case])) { ConfidenceFromRelativeDistance = 1; } else { ConfidenceFromRelativeDistance = FuzzyFunctionSampleMismatches(RelativeDistanceHistory[Case]); } ConfidenceOfBestFittingSample = fuzzyOR(ConfidenceOfBestFittingSample, ConfidenceFromRelativeDistance); ConfidenceOfWorstCase = fuzzyAND(ConfidenceOfWorstCase, fuzzyOR(ConfidenceOfBestFittingSample, FuzzyFunctionNumOfSamplesMismatches( static_cast(Case) + 1))); } TempConfidenceMismatching = ConfidenceOfWorstCase; return ConfidenceOfWorstCase; } /// Gives information about the current signal state. /// /// \return a struct SignalStateInformation that contains information about /// the current signal state. SignalStateInformation signalStateInformation(void) noexcept { return SignalStateInfo; } private: void validateSignalState(INDATATYPE Sample) { // TODO (future): WorstConfidenceDistance and BestConfidenceDistance could // be set already in "CONFDATATYPE // confidenceSampleMatchesSignalState(INDATATYPE Sample)" and "CONFDATATYPE // confidenceSampleMismatchesSignalState(INDATATYPE Sample)" when the new // sample is compared to all history samples. This would save a lot time // because the comparisons are done only once. However, it has to be asured // that the these two functions are called before the insertation, and the // FuzzyFunctions for validation and matching have to be the same! CONFDATATYPE LowestConfidenceMatching = 1; CONFDATATYPE HighestConfidenceMismatching = 0; for (auto &HistorySample : SampleHistory) { // TODO (future): think about using different fuzzy functions for // validation and matching. LowestConfidenceMatching = fuzzyAND( LowestConfidenceMatching, FuzzyFunctionSampleMatches(relativeDistance( Sample, HistorySample))); HighestConfidenceMismatching = fuzzyOR(HighestConfidenceMismatching, FuzzyFunctionSampleMismatches( relativeDistance( Sample, HistorySample))); } LowestConfidenceMatchingHistory.addEntry(LowestConfidenceMatching); HighestConfidenceMismatchingHistory.addEntry(HighestConfidenceMismatching); LowestConfidenceMatching = LowestConfidenceMatchingHistory.lowestEntry(); HighestConfidenceMismatching = HighestConfidenceMismatchingHistory.highestEntry(); SignalStateInfo.ConfidenceStateIsValid = fuzzyAND(LowestConfidenceMatching, FuzzyFunctionNumOfSamplesValid(static_cast( SignalStateInfo.NumberOfInsertedSamplesAfterEntrance))); SignalStateInfo.ConfidenceStateIsInvalid = fuzzyOR(HighestConfidenceMismatching, FuzzyFunctionNumOfSamplesInvalid(static_cast( SignalStateInfo.NumberOfInsertedSamplesAfterEntrance))); if (SignalStateInfo.ConfidenceStateIsValid > SignalStateInfo.ConfidenceStateIsInvalid) { if (SignalStateInfo.StateIsValid) { SignalStateInfo.StateJustGotValid = false; } else { SignalStateInfo.StateJustGotValid = true; } SignalStateInfo.StateIsValid = true; SignalStateInfo.StateIsValidAfterReentrance = true; } } void checkSignalStability(void) { /* std::cout << "LookbackTest: " << std::endl; for (unsigned int t = 1; t <= DriftLookbackRange + 5; t++) { std::cout << "t=" << t << " -> c=" << FuzzyFunctionSignalConditionLookBack(t) << std::endl; //(*FuzzyFunctionTimeSystemFunctioning)( // static_cast(TimeOfDisparity)); } getchar(); */ SignalStateInfo.ConfidenceStateIsStable = 0; SignalStateInfo.ConfidenceStateIsDrifting = 0; /* std::cout << "ConfidenceStateIsStable (before): " << SignalStateInfo.ConfidenceStateIsStable << std::endl; std::cout << "ConfidenceStateIsDrifting (before): " << SignalStateInfo.ConfidenceStateIsDrifting << std::endl; */ if (DABHistory.numberOfEntries() >= 2) { + /* + // EXPERIMENTING + for (unsigned int t = 1; + t <= DriftLookbackRange && t < DABHistory.numberOfEntries(); + t++) { + + // AND + + SignalStateInfo.ConfidenceStateIsStable = fuzzyOR( + SignalStateInfo.ConfidenceStateIsStable, + fuzzyAND( + FuzzyFunctionSignalIsStable( + relativeDistance( + DABHistory[DABHistory.numberOfEntries() - 1], + DABHistory[DABHistory.numberOfEntries() - (t + + 1)])), FuzzyFunctionSignalConditionLookBack(t))); + + SignalStateInfo.ConfidenceStateIsDrifting = fuzzyOR( + SignalStateInfo.ConfidenceStateIsDrifting, + fuzzyAND( + FuzzyFunctionSignalIsDrifting( + relativeDistance( + DABHistory[DABHistory.numberOfEntries() - 1], + DABHistory[DABHistory.numberOfEntries() - (t + + 1)])), FuzzyFunctionSignalConditionLookBack(t))); */ - // EXPERIMENTING - for (unsigned int t = 1; - t <= DriftLookbackRange && t < DABHistory.numberOfEntries(); t++) { - - // AND - - SignalStateInfo.ConfidenceStateIsStable = fuzzyOR( - SignalStateInfo.ConfidenceStateIsStable, - fuzzyAND( - FuzzyFunctionSignalIsStable( - relativeDistance( - DABHistory[DABHistory.numberOfEntries() - 1], - DABHistory[DABHistory.numberOfEntries() - (t + 1)])), - FuzzyFunctionSignalConditionLookBack(t))); - - SignalStateInfo.ConfidenceStateIsDrifting = fuzzyOR( - SignalStateInfo.ConfidenceStateIsDrifting, - fuzzyAND( - FuzzyFunctionSignalIsDrifting( - relativeDistance( - DABHistory[DABHistory.numberOfEntries() - 1], - DABHistory[DABHistory.numberOfEntries() - (t + 1)])), - FuzzyFunctionSignalConditionLookBack(t))); - - /* - std::cout - << "t=" << t - << ", DABact=" << DABHistory[DABHistory.numberOfEntries() - - 1] - << ", DAB_t-" << t << "=" - << DABHistory[DABHistory.numberOfEntries() - (t + 1)] - << " / FuzzyStb=" - << FuzzyFunctionSignalIsStable( - relativeDistance( - DABHistory[DABHistory.numberOfEntries() - 1], - DABHistory[DABHistory.numberOfEntries() - (t + - 1)])) - << ", FuzzyDft=" - << FuzzyFunctionSignalIsDrifting( - relativeDistance( - DABHistory[DABHistory.numberOfEntries() - 1], - DABHistory[DABHistory.numberOfEntries() - (t + - 1)])) - << ", FuzzyLB=" << FuzzyFunctionSignalConditionLookBack(t) - << std::endl; - */ - // MULTI - /* - SignalStateInfo.ConfidenceStateIsStable = fuzzyOR( - SignalStateInfo.ConfidenceStateIsStable, - FuzzyFunctionSignalIsStable( - relativeDistance( - DABHistory[DABHistory.numberOfEntries() - 1], - DABHistory[DABHistory.numberOfEntries() - (t + 1)])) - * FuzzyFunctionSignalConditionLookBack(t)); - - SignalStateInfo.ConfidenceStateIsDrifting = fuzzyOR( - SignalStateInfo.ConfidenceStateIsDrifting, - FuzzyFunctionSignalIsDrifting( - relativeDistance( - DABHistory[DABHistory.numberOfEntries() - 1], - DABHistory[DABHistory.numberOfEntries() - (t + 1)])) - * FuzzyFunctionSignalConditionLookBack(t)); - */ - // std::cout << "t = " << t << ", HistLength = " << - // DABHistory.numberOfEntries() << std::endl; - } + /* + std::cout + << "t=" << t + << ", DABact=" << DABHistory[DABHistory.numberOfEntries() - + 1] + << ", DAB_t-" << t << "=" + << DABHistory[DABHistory.numberOfEntries() - (t + 1)] + << " / FuzzyStb=" + << FuzzyFunctionSignalIsStable( + relativeDistance( + DABHistory[DABHistory.numberOfEntries() - 1], + DABHistory[DABHistory.numberOfEntries() - (t + + 1)])) + << ", FuzzyDft=" + << FuzzyFunctionSignalIsDrifting( + relativeDistance( + DABHistory[DABHistory.numberOfEntries() - 1], + DABHistory[DABHistory.numberOfEntries() - (t + + 1)])) + << ", FuzzyLB=" << FuzzyFunctionSignalConditionLookBack(t) + << std::endl; + */ + // MULTI + /* + SignalStateInfo.ConfidenceStateIsStable = fuzzyOR( + SignalStateInfo.ConfidenceStateIsStable, + FuzzyFunctionSignalIsStable( + relativeDistance( + DABHistory[DABHistory.numberOfEntries() - 1], + DABHistory[DABHistory.numberOfEntries() - (t + 1)])) + * FuzzyFunctionSignalConditionLookBack(t)); + + SignalStateInfo.ConfidenceStateIsDrifting = fuzzyOR( + SignalStateInfo.ConfidenceStateIsDrifting, + FuzzyFunctionSignalIsDrifting( + relativeDistance( + DABHistory[DABHistory.numberOfEntries() - 1], + DABHistory[DABHistory.numberOfEntries() - (t + 1)])) + * FuzzyFunctionSignalConditionLookBack(t)); + */ + // std::cout << "t = " << t << ", HistLength = " << + // DABHistory.numberOfEntries() << std::endl; + //} // EXPERIMENTING -> following outcommented block was the published code - /* + SignalStateInfo.ConfidenceStateIsStable = FuzzyFunctionSignalIsStable( relativeDistance( DABHistory[DABHistory.numberOfEntries() - 1], DABHistory[0])); SignalStateInfo.ConfidenceStateIsDrifting = FuzzyFunctionSignalIsDrifting( relativeDistance( DABHistory[DABHistory.numberOfEntries() - 1], DABHistory[0])); - */ } /* std::cout << "ConfidenceStateIsStable (after): " << SignalStateInfo.ConfidenceStateIsStable << std::endl; std::cout << "ConfidenceStateIsDrifting (after): " << SignalStateInfo.ConfidenceStateIsDrifting << std::endl; */ /* else { // Initializing the following variables because (at this moment) we do not // know if the signal is stable or drifting. SignalStateInfo.ConfidenceStateIsStable = 0; SignalStateInfo.ConfidenceStateIsDrifting = 0; } */ if (SignalStateInfo.ConfidenceStateIsStable > SignalStateInfo.ConfidenceStateIsDrifting) { SignalStateInfo.StateCondition = StateConditions::STABLE; } else if (SignalStateInfo.ConfidenceStateIsStable < SignalStateInfo.ConfidenceStateIsDrifting) { SignalStateInfo.StateCondition = StateConditions::DRIFTING; } else { SignalStateInfo.StateCondition = StateConditions::UNKNOWN; /* if (SignalStateInfo.ConfidenceStateIsStable != 0) getchar(); */ } } }; } // End namespace agent } // End namespace rosa #endif // ROSA_AGENT_SIGNALSTATE_HPP diff --git a/include/rosa/agent/SignalStateDetector.hpp b/include/rosa/agent/SignalStateDetector.hpp index 320b69c..8a7d3c1 100644 --- a/include/rosa/agent/SignalStateDetector.hpp +++ b/include/rosa/agent/SignalStateDetector.hpp @@ -1,330 +1,332 @@ //===-- rosa/agent/SignalStateDetector.hpp ----------------------*- C++ -*-===// // // The RoSA Framework // // Distributed under the terms and conditions of the Boost Software License 1.0. // See accompanying file LICENSE. // // If you did not receive a copy of the license file, see // http://www.boost.org/LICENSE_1_0.txt. // //===----------------------------------------------------------------------===// /// /// \file rosa/agent/SignalStateDetector.hpp /// /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at) /// /// \date 2019 /// /// \brief Definition of *signal state detector* *functionality*. /// //===----------------------------------------------------------------------===// #ifndef ROSA_AGENT_SIGNALSTATEDETECTOR_HPP #define ROSA_AGENT_SIGNALSTATEDETECTOR_HPP #include "rosa/agent/Functionality.h" #include "rosa/agent/SignalState.hpp" #include "rosa/agent/StateDetector.hpp" #include namespace rosa { namespace agent { /// Implements \c rosa::agent::SignalStateDetector as a functionality that /// detects signal states given on input samples. /// /// \note This implementation is supposed to be used for samples of an /// arithmetic type. /// /// \tparam INDATATYPE type of input data, \tparam CONFDATATYPE type of /// data in that the confidence values are given, \tparam PROCDATATYPE type of /// the relative distance and the type of data in which DABs are saved. template class SignalStateDetector : public StateDetector { using StateDetector = StateDetector; using PartFuncPointer = typename StateDetector::PartFuncPointer; using StepFuncPointer = typename StateDetector::StepFuncPointer; private: // For the convinience to write a shorter data type name using SignalStatePtr = std::shared_ptr>; /// The SignalProperty saves whether the monitored signal is an input our /// output signal. SignalProperties SignalProperty; /// The CurrentSignalState is a pointer to the (saved) signal state in which /// the actual variable (signal) of the observed system is. SignalStatePtr CurrentSignalState; /// The DetectedSignalStates is a history in that all detected signal states /// are saved. DynamicLengthHistory DetectedSignalStates; /// The FuzzyFunctionSampleMatches is the fuzzy function that gives the /// confidence how good the new sample matches another sample in the sample /// history. This is done to evaluate whether one sample belongs to an /// existing state. PartFuncPointer FuzzyFunctionSampleMatches; /// The FuzzyFunctionSampleMismatches is the fuzzy function that gives the /// confidence how bad the new sample matches another sample in the sample /// history. This is done to evaluate whether one sample does not belong to an /// existing state. PartFuncPointer FuzzyFunctionSampleMismatches; /// The FuzzyFunctionNumOfSamplesMatches is the fuzzy function that gives the /// confidence how many samples from the sample history match the new sample. /// This is done to evaluate whether one sample belongs to an existing state. StepFuncPointer FuzzyFunctionNumOfSamplesMatches; /// The FuzzyFunctionNumOfSamplesMismatches is the fuzzy function that gives /// the confidence how many samples from the sample history mismatch the new /// sample. This is done to evaluate whether one sample does not belong to an /// existing state. StepFuncPointer FuzzyFunctionNumOfSamplesMismatches; /// The FuzzyFunctionSampleValid is the fuzzy function that gives the /// confidence how good one matches another sample in the sample /// history. This is done to evaluate whether a state is valid. PartFuncPointer FuzzyFunctionSampleValid; /// The FuzzyFunctionSampleInvalid is the fuzzy function that gives the /// confidence how bad one sample matches another sample in the sample /// history. This is done to evaluate whether a state is invalid. PartFuncPointer FuzzyFunctionSampleInvalid; /// The FuzzyFunctionNumOfSamplesValid is the fuzzy function that gives the /// confidence how many samples from the sample history match another sample. /// This is done to evaluate whether a state is valid. StepFuncPointer FuzzyFunctionNumOfSamplesValid; /// The FuzzyFunctionNumOfSamplesInvalid is the fuzzy function that gives /// the confidence how many samples from the sample history mismatch another /// sample. This is done to evaluate whether a state is invalid. StepFuncPointer FuzzyFunctionNumOfSamplesInvalid; /// The FuzzyFunctionSignalIsDrifting is the fuzzy function that gives the /// confidence how likely it is that the signal is drifting. PartFuncPointer FuzzyFunctionSignalIsDrifting; /// The FuzzyFunctionSignalIsStable is the fuzzy function that gives the /// confidence how likely it is that the signal is stable (not drifting). PartFuncPointer FuzzyFunctionSignalIsStable; /// TODO: describe std::shared_ptr> FuzzyFunctionSignalConditionLookBack; /// TODO: describe std::shared_ptr> FuzzyFunctionSignalConditionHistoryDesicion; /// TODO: describe uint32_t DriftLookbackRange; /// SampleHistorySize is the (maximum) size of the sample history. uint32_t SampleHistorySize; /// DABSize the size of a DAB (Discrete Average Block). uint32_t DABSize; /// DABHistorySize is the (maximum) size of the DAB history. uint32_t DABHistorySize; public: /// Creates an instance by setting all parameters /// \param FuzzyFunctionSampleMatches The FuzzyFunctionSampleMatches is the /// fuzzy function that gives the confidence how good the new sample matches /// another sample in the sample history. /// /// \param FuzzyFunctionSampleMismatches The FuzzyFunctionSampleMismatches is /// the fuzzy function that gives the confidence how bad the new sample /// matches another sample in the sample history. /// /// \param FuzzyFunctionNumOfSamplesMatches The /// FuzzyFunctionNumOfSamplesMatches is the fuzzy function that gives the /// confidence how many samples from the sampe history match the new sample. /// /// \param FuzzyFunctionNumOfSamplesMismatches The /// FuzzyFunctionNumOfSamplesMismatches is the fuzzy function that gives the /// confidence how many samples from the sampe history mismatch the new /// sample. /// /// \param FuzzyFunctionSignalIsDrifting The FuzzyFunctionSignalIsDrifting is /// the fuzzy function that gives the confidence how likely it is that the /// signal (resp. the state of a signal) is drifting. /// /// \param FuzzyFunctionSignalIsStable The FuzzyFunctionSignalIsStable is the /// fuzzy function that gives the confidence how likely it is that the signal /// (resp. the state of a signal) is stable (not drifting). /// /// \param SampleHistorySize Sets the History size which will be used by \c /// SignalState. /// /// \param DABSize Sets the DAB size which will be used by \c SignalState. /// /// \param DABHistorySize Sets the size which will be used by \c SignalState. /// SignalStateDetector(SignalProperties SignalProperty, uint32_t MaximumNumberOfSignalStates, PartFuncPointer FuzzyFunctionSampleMatches, PartFuncPointer FuzzyFunctionSampleMismatches, StepFuncPointer FuzzyFunctionNumOfSamplesMatches, StepFuncPointer FuzzyFunctionNumOfSamplesMismatches, PartFuncPointer FuzzyFunctionSampleValid, PartFuncPointer FuzzyFunctionSampleInvalid, StepFuncPointer FuzzyFunctionNumOfSamplesValid, StepFuncPointer FuzzyFunctionNumOfSamplesInvalid, PartFuncPointer FuzzyFunctionSignalIsDrifting, PartFuncPointer FuzzyFunctionSignalIsStable, - std::shared_ptr> - FuzzyFunctionSignalConditionLookBack, - std::shared_ptr> - FuzzyFunctionSignalConditionHistoryDesicion, - uint32_t DriftLookbackRange, uint32_t SampleHistorySize, - uint32_t DABSize, uint32_t DABHistorySize) noexcept + // std::shared_ptr> + // FuzzyFunctionSignalConditionLookBack, + // std::shared_ptr> + // FuzzyFunctionSignalConditionHistoryDesicion, + // uint32_t DriftLookbackRange, + uint32_t SampleHistorySize, uint32_t DABSize, + uint32_t DABHistorySize) noexcept : SignalProperty(SignalProperty), CurrentSignalState(nullptr), DetectedSignalStates(MaximumNumberOfSignalStates), FuzzyFunctionSampleMatches(FuzzyFunctionSampleMatches), FuzzyFunctionSampleMismatches(FuzzyFunctionSampleMismatches), FuzzyFunctionNumOfSamplesMatches(FuzzyFunctionNumOfSamplesMatches), FuzzyFunctionNumOfSamplesMismatches( FuzzyFunctionNumOfSamplesMismatches), FuzzyFunctionSampleValid(FuzzyFunctionSampleValid), FuzzyFunctionSampleInvalid(FuzzyFunctionSampleInvalid), FuzzyFunctionNumOfSamplesValid(FuzzyFunctionNumOfSamplesValid), FuzzyFunctionNumOfSamplesInvalid(FuzzyFunctionNumOfSamplesInvalid), FuzzyFunctionSignalIsDrifting(FuzzyFunctionSignalIsDrifting), FuzzyFunctionSignalIsStable(FuzzyFunctionSignalIsStable), - FuzzyFunctionSignalConditionLookBack( - FuzzyFunctionSignalConditionLookBack), - FuzzyFunctionSignalConditionHistoryDesicion( - FuzzyFunctionSignalConditionHistoryDesicion), - DriftLookbackRange(DriftLookbackRange), + // FuzzyFunctionSignalConditionLookBack( + // FuzzyFunctionSignalConditionLookBack), + // FuzzyFunctionSignalConditionHistoryDesicion( + // FuzzyFunctionSignalConditionHistoryDesicion), + // DriftLookbackRange(DriftLookbackRange), SampleHistorySize(SampleHistorySize), DABSize(DABSize), DABHistorySize(DABHistorySize) { this->NextStateID = 1; this->StateHasChanged = false; } /// Destroys \p this object. ~SignalStateDetector(void) = default; /// Detects the signal state to which the new sample belongs or create a new /// signal state if the new sample does not match to any of the saved states. /// /// \param Sample is the actual sample of the observed signal. /// /// \return the information of the current signal state (signal state ID and /// other parameters). // TODO (future): change this function to an operator()-function SignalStateInformation detectSignalState(INDATATYPE Sample) noexcept { if (!CurrentSignalState) { ASSERT(DetectedSignalStates.empty()); SignalStatePtr S = createNewSignalState(); CurrentSignalState = S; } else { // TODO (future): maybe there is a better way than a relative distance // comparison. Maybe somehow a mix of relative and absolute? CONFDATATYPE ConfidenceSampleMatchesSignalState = CurrentSignalState->confidenceSampleMatchesSignalState(Sample); CONFDATATYPE ConfidenceSampleMismatchesSignalState = CurrentSignalState->confidenceSampleMismatchesSignalState(Sample); this->StateHasChanged = ConfidenceSampleMatchesSignalState <= ConfidenceSampleMismatchesSignalState; if (this->StateHasChanged) { if (CurrentSignalState->signalStateInformation().StateIsValid) CurrentSignalState->leaveSignalState(); else DetectedSignalStates.deleteEntry(CurrentSignalState); // TODO (future): additionally save averages to enable fast iteration // through recorded signl state history (maybe sort vector based on // these average values) CurrentSignalState = nullptr; for (auto &SavedSignalState : DetectedSignalStates) { ConfidenceSampleMatchesSignalState = SavedSignalState->confidenceSampleMatchesSignalState(Sample); ConfidenceSampleMismatchesSignalState = SavedSignalState->confidenceSampleMismatchesSignalState(Sample); if (ConfidenceSampleMatchesSignalState > ConfidenceSampleMismatchesSignalState) { // TODO (future): maybe it would be better to compare // ConfidenceSampleMatchesSignalState of all signal states in the // vector in order to find the best matching signal state. CurrentSignalState = SavedSignalState; break; } } if (!CurrentSignalState) { SignalStatePtr S = createNewSignalState(); CurrentSignalState = S; } } } SignalStateInformation SignalStateInfo = CurrentSignalState->insertSample(Sample); if (SignalStateInfo.StateJustGotValid) { this->NextStateID++; } return SignalStateInfo; } /// Gives information about the current signal state. /// /// \return a struct SignalStateInformation that contains information about /// the current signal state or NULL if no current signal state exists. SignalStateInformation currentSignalStateInformation(void) noexcept { if (CurrentSignalState) { return CurrentSignalState->signalStateInformation(); } else { return NULL; } } /// Gives information whether a signal state change has happened or not. /// /// \return true if a signal state change has happened, and false if not. bool stateHasChanged(void) noexcept { return this->StateHasChanged; } private: /// Creates a new signal state and adds it to the signal state vector in which /// all known states are saved. /// /// \return a pointer to the newly created signal state or NULL if no state /// could be created. SignalStatePtr createNewSignalState(void) noexcept { SignalStatePtr S(new SignalState( this->NextStateID, SignalProperty, SampleHistorySize, DABSize, DABHistorySize, *FuzzyFunctionSampleMatches, *FuzzyFunctionSampleMismatches, *FuzzyFunctionNumOfSamplesMatches, *FuzzyFunctionNumOfSamplesMismatches, *FuzzyFunctionSampleValid, *FuzzyFunctionSampleInvalid, *FuzzyFunctionNumOfSamplesValid, *FuzzyFunctionNumOfSamplesInvalid, *FuzzyFunctionSignalIsDrifting, - *FuzzyFunctionSignalIsStable, *FuzzyFunctionSignalConditionLookBack, - *FuzzyFunctionSignalConditionHistoryDesicion, DriftLookbackRange)); + *FuzzyFunctionSignalIsStable //, *FuzzyFunctionSignalConditionLookBack, + //*FuzzyFunctionSignalConditionHistoryDesicion, DriftLookbackRange + )); DetectedSignalStates.addEntry(S); return S; } }; } // End namespace agent } // End namespace rosa #endif // ROSA_AGENT_SIGNALSTATEDETECTOR_HPP diff --git a/include/rosa/agent/State.hpp b/include/rosa/agent/State.hpp index 68c9e15..12512ff 100644 --- a/include/rosa/agent/State.hpp +++ b/include/rosa/agent/State.hpp @@ -1,100 +1,100 @@ //===-- rosa/agent/State.hpp ------------------------------------*- C++ -*-===// // // The RoSA Framework // // Distributed under the terms and conditions of the Boost Software License 1.0. // See accompanying file LICENSE. // // If you did not receive a copy of the license file, see // http://www.boost.org/LICENSE_1_0.txt. // //===----------------------------------------------------------------------===// /// /// \file rosa/agent/State.hpp /// /// \author Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at) /// /// \date 2019 /// /// \brief Definition of *state* *functionality*. /// //===----------------------------------------------------------------------===// #ifndef ROSA_AGENT_STATE_HPP #define ROSA_AGENT_STATE_HPP #include "rosa/agent/Functionality.h" //#include "rosa/agent/FunctionAbstractions.hpp" //#include "rosa/agent/History.hpp" #include "rosa/support/debug.hpp" #include //#include namespace rosa { namespace agent { /// State conditions defining how the condition of a \c rosa::agent::State is /// saved in \c rosa::agent::StateInformation. -enum StateConditions : char { +enum StateConditions : uint8_t { /* UNKNOWN = 0, ///< The state is unknown STABLE = 1, ///< The state is stable DRIFTING_UP = 2, ///< The state is drifting up DRIFTING_DN = 3, ///< The state is drifting down MALFUNCTIONING = 4 ///< Malfunction */ UNKNOWN = 0, ///< The state is unknown STABLE = 1, ///< The state is stable DRIFTING = 2, ///< The state is drifting MALFUNCTIONING = 3 ///< Malfunction }; template struct StateInformation { // Make sure the actual type arguments are matching our expectations. STATIC_ASSERT((std::is_arithmetic::value), "confidence type is not to arithmetic"); /// The StateID stores the ID of the state. unsigned int StateID; /// The StateCondition shows the condition of a state (stable, drifting, or /// unknown) StateConditions StateCondition; /// The StateIsValid shows whether a state is valid or invalid. In this /// context, valid means that enough samples which are in close proximitry /// have been inserted into the state. bool StateIsValid; /// The StateJustGotValid shows whether a state got valid (toggled from /// invalid to valid) during the current inserted sample. bool StateJustGotValid; /// The StateIsValidAfterReentrance shows whether a state is valid after the /// variable changed back to it again. bool StateIsValidAfterReentrance; /// TODO: describe CONFDATATYPE ConfidenceStateIsValid; CONFDATATYPE ConfidenceStateIsInvalid; CONFDATATYPE ConfidenceStateIsStable; CONFDATATYPE ConfidenceStateIsDrifting; }; template class State : public Functionality { // Make sure the actual type arguments are matching our expectations. STATIC_ASSERT((std::is_arithmetic::value), "input data type not arithmetic"); STATIC_ASSERT((std::is_arithmetic::value), "confidence abstraction type is not to arithmetic"); STATIC_ASSERT((std::is_arithmetic::value), "process type is not to arithmetic"); protected: }; } // End namespace agent } // End namespace rosa #endif // ROSA_AGENT_SIGNALSTATEDETECTOR_HPP diff --git a/include/rosa/support/mqtt/MQTTReader.hpp b/include/rosa/support/mqtt/MQTTReader.hpp new file mode 100644 index 0000000..92c900f --- /dev/null +++ b/include/rosa/support/mqtt/MQTTReader.hpp @@ -0,0 +1,270 @@ +//===-- rosa/support/MQTT/MQTTReader.hpp --------------------------*- C++ -*-===// +// +// The RoSA Framework +// +// Distributed under the terms and conditions of the Boost Software License 1.0. +// See accompanying file LICENSE. +// +// If you did not receive a copy of the license file, see +// http://www.boost.org/LICENSE_1_0.txt. +// +//===----------------------------------------------------------------------===// +/// +/// \file rosa/support/MQTT/MQTTReader.hpp +/// +/// \authors Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at), +/// Maximilian Götzinger (maximilian.goetzinger@tuwien.ac.at) +/// +/// \date 2020 +/// +/// \brief Facitilities to read from MQTT brokers. +/// +//===----------------------------------------------------------------------===// + +#ifndef ROSA_SUPPORT_MQTT_MQTTREADER_HPP +#define ROSA_SUPPORT_MQTT_MQTTREADER_HPP + +#include "rosa/support/debug.hpp" +#include "rosa/support/sequence.hpp" +#include "mqtt/async_client.h" + +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace rosa { +namespace MQTT { + + +// @TODO this is a copy of CSVReader.hpp. Move this functionalities to common file +/// Anonymous namespace providing implementation details for +/// \c rosa::csv::CSVIterator, consider it private. +namespace { + +/// Provides facility for parsing one value from a string. +/// +/// \tparam T type of value to parse +/// \tparam IsSignedInt if \p T is a signed integral type, always use default +/// \tparam IsUnsignedInt if \p T is an unsigned integral type, always use +/// default +/// \tparam IsFloat if \p T is a floating-point type, always use default +/// \tparam IsString if \p T is \c std::string, always use default +/// +/// \note Specializations of this struct are provided for arithmentic types +/// and \c std::string. +template ::value && std::is_signed::value), + bool IsUnsignedInt = + (std::is_integral::value && std::is_unsigned::value), + bool IsFloat = std::is_floating_point::value, + bool IsString = std::is_same::value> +struct ValueParser { + + /// + /// + /// \param Cell the \c std::string to parse + /// + /// \return the parsed value + /// + /// \note The function silently fails if cannot parse \p Cell for type \p T. + static T parse(const std::string &Cell) noexcept; +}; + +template struct ValueParser { + STATIC_ASSERT((std::is_integral::value && std::is_signed::value), + "wrong type"); // Sanity check. + static T parse(const std::string &Cell) noexcept { + return static_cast(std::stoll(Cell)); + } +}; + +template struct ValueParser { + STATIC_ASSERT((std::is_integral::value && std::is_unsigned::value), + "wrong type"); // Sanity check. + static T parse(const std::string &Cell) noexcept { + return static_cast(std::stoull(Cell)); + } +}; + +template struct ValueParser { + STATIC_ASSERT((std::is_floating_point::value), + "wrong type"); // Sanity check. + static T parse(const std::string &Cell) noexcept { + return static_cast(std::stold(Cell)); + } +}; + +template struct ValueParser { + STATIC_ASSERT((std::is_same::value), + "wrong type"); // Sanity check. + static T parse(const std::string &Cell) noexcept { return Cell; } +}; + +} // End namespace + +/// Provides `InputIterator` features for iterating over a MQTT file. +/// +/// The iterator parses rows into `std::tuple` values and iterates over the +/// file row by row. +/// +/// \tparam T type of values stored in one row of the MQTT file +/// +/// \note The iterator expects each row to consists of fields matching \p Ts. +/// +/// \note The implementation relies on \c rosa::MQTT::MQTTRow, which in turn +/// relies on \c rosa::MQTT::MQTTRowParser, which is implemented only for +/// `arithmetic` types -- signed and unsigned integral types and floating-point +/// types -- and for \c std::string. Those are the valid values for \p Ts +template class MQTTIterator : public virtual mqtt::callback { +public: + /// \defgroup MQTTIteratorTypedefs Typedefs of rosa::MQTT::MQTTIterator + /// + /// Standard `typedef`s for iterators. + /// + ///@{ + typedef std::input_iterator_tag + iterator_category; ///< Category of the iterator. + typedef T value_type; ///< Type of values iterated over. + typedef std::size_t difference_type; ///< Type to identify distance. + typedef T *pointer; ///< Pointer to the type iterated over. + typedef T &reference; ///< Reference to the type iterated over. + ///@} + + + /// Creates a new instance. + /// + /// \param [in,out] S input stream to iterate over + /// \param SkipRows the number of rows you want to skip only once at + /// the beginning of the file. + /// If you have an header in the file, it is supposed to be + /// the first row, and it will be always read out. But after + /// this header the next number of Rows will be skipped. + /// \param HeaderInfo is used to know wheter the file contains an + /// header row or not. + /// The header has to be in the first row. + /// \param Delimiter is the separator between the differnt values of + /// the MQTT file. + MQTTIterator(std::string &MQTTTopic, std::string ServerHost = "localhost", uint16_t ServerPort = 1883, size_t TimeoutSecs = 60) { + this->MQTTTopic = MQTTTopic; + this->ServerHost = ServerHost; + this->ServerPort = ServerPort; + this->TimeoutSecs = TimeoutSecs; + //connect and register callback + try { + std::stringstream ss; + ss << "tcp://" << ServerHost << ":" << ServerPort; + const std::string ServerURI = ss.str(); + LOG_INFO_STREAM << "Initializing for " << ServerURI << std::endl; + mqtt::async_client Client(ServerURI, ""); + + LOG_INFO_STREAM << "Connecting to server" << std::endl; + Client.connect()->wait(); + LOG_INFO_STREAM << "Receiving messages from topic '" << Topic + << "' for a short while..." << std::endl; + Client.set_callback(this); + Client.subscribe(this->MQTTTopic, {}); + + //@todo move to destructor + //Client.disconnect()->wait(); + + } catch (const mqtt::exception &e) { + logErrorAndExit(e.what(), 1); + } + } + + /// Creates an empty new instance. + MQTTIterator(void) noexcept {} + + /// Pre-increment operator. + /// + /// The implementation reads the next row. If the end of the input stream is + /// reached, the operator becomes empty and has no further effect. + /// + /// \return \p this object after incrementing it. + MQTTIterator &operator++() { + buffer.pop_front(); + return *this; + } + + /// Post-increment operator. + /// + /// The implementation uses the pre-increment operator and returns a copy of + /// the original state of \p this object. + /// + /// \return \p this object before incrementing it. + MQTTIterator operator++(int) { + MQTTIterator Tmp(*this); + ++(*this); + return Tmp; + } + + /// Returns a constant reference to the current entry. + /// + /// \note Should not dereference the iterator when it is empty. + /// + /// \return constant reference to the current entry. + const T &operator*(void)const noexcept { return buffer.front() } + + /// Returns a constant pointer to the current entry. + /// + /// \note Should not dereference the iterator when it is empty. + /// + /// \return constant pointer to the current entry. + const T *operator->(void)const noexcept { + return &(buffer.front()); + } + + /// Tells if \p this object is equal to another one. + /// + /// Two \c rosa::MQTT::MQTTIterator instances are equal if and only if they are + /// the same or both are empty. + /// + /// \param RHS other object to compare to + /// + /// \return whether \p this object is equal with \p RHS + bool operator==(const MQTTIterator &RHS) const noexcept { + return ((this == &RHS) || ((this->buffer.empty()) && (RHS.buffer.empty()))); + } + + /// Tells if \p this object is not equal to another one. + /// + /// \see rosa::MQTT::MQTTIterator::operator== + /// + /// \param RHS other object to compare to + /// + /// \return whether \p this object is not equal with \p RHS. + bool operator!=(const MQTTIterator &RHS) const noexcept { + return !((*this) == RHS); + } + + /** Callback for when a message arrives. + * @param Msg Pointer for the MQTT message + **/ + void message_arrived(mqtt::const_message_ptr Msg) override { + std::string Topic = Msg->get_topic(); + std::string Message = Msg->to_string(); + LOG_INFO_STREAM << "[Message @ " << Topic << "] " << Message << std::endl; + //@todo convert and enqueue value + buffer.push_back(parser.parse(Message)); + } + +private: + std::string ServerHost; + uint16_t ServerPort; + type_t TimeoutSecs; + std::string MQTTTopic; + std::queue buffer; + ValueParser parser; +}; + +} // End namespace MQTT +} // End namespace rosa + +#endif // ROSA_SUPPORT_MQTT_MQTTREADER_HPP diff --git a/include/rosa/support/mqtt/namespace.h b/include/rosa/support/mqtt/namespace.h new file mode 100644 index 0000000..b293c3f --- /dev/null +++ b/include/rosa/support/mqtt/namespace.h @@ -0,0 +1,31 @@ +//===-- rosa/support/csv/namespace.h ----------------------------*- C++ -*-===// +// +// The RoSA Framework +// +// Distributed under the terms and conditions of the Boost Software License 1.0. +// See accompanying file LICENSE. +// +// If you did not receive a copy of the license file, see +// http://www.boost.org/LICENSE_1_0.txt. +// +//===----------------------------------------------------------------------===// +/// +/// \file rosa/support/mqtt/namespace.h +/// +/// \author Benedikt Tutzer (benedikt.tutzer@tuwien.ac.at) +/// +/// \date 2020 +/// +/// \brief Documentation for the namespace \c rosa::mqtt. +/// +//===----------------------------------------------------------------------===// + +#ifndef ROSA_SUPPORT_MQTT_NAMESPACE_H +#define ROSA_SUPPORT_MQTT_NAMESPACE_H + +namespace rosa { +/// Provides facilities to work with mqtt brokers. +namespace mqtt {} +} // End namespace rosa + +#endif // ROSA_SUPPORT_MQTT_NAMESPACE_H