diff --git a/Version_Max_07_05_2018_CMake/src/Agent.cpp b/Version_Max_07_05_2018_CMake/src/Agent.cpp index fa63204..ec72717 100755 --- a/Version_Max_07_05_2018_CMake/src/Agent.cpp +++ b/Version_Max_07_05_2018_CMake/src/Agent.cpp @@ -1,1086 +1,262 @@ #include "Agent.h" #include "printError.h" #include //TODO: Move this include to ControlModule #include "instruction_set_architecture.h" /* #include "Evaluation.h" #include "instruction_set_architecture.h" */ #define PRINT_READING void Agent :: init_agent() { sensorHandlerOfAgent = NULL; slaveAgentHandlerOfAgent = NULL; masterAgentHandlerOfAgent = NULL; stateHandler = NULL; workingCycleCounter = 0; } Agent :: Agent() { set_name(NO_NAME); init_agent(); } -Agent :: Agent(char* name) { +Agent :: Agent(string name) { set_name(name); init_agent(); } bool Agent :: set_sensorHandlerOfAgent() { sensorHandlerOfAgent = new SensorHandlerOfAgent(); if(sensorHandlerOfAgent == NULL) { printError("Couldn't create Sensor Handler!"); return false; } return true; } bool Agent :: del_sensorHandlerOfAgent() { if(sensorHandlerOfAgent != NULL) { //TODO: Unmount/delete all sensorSlots with everything inside (history module, confidence module, ...) delete sensorHandlerOfAgent; return true; } return false; } SensorHandlerOfAgent* Agent :: get_sensorHandlerOfAgent() { if(sensorHandlerOfAgent == NULL) { set_sensorHandlerOfAgent(); } return sensorHandlerOfAgent; } bool Agent :: set_slaveAgentHandlerOfAgent() { slaveAgentHandlerOfAgent = new SlaveAgentHandlerOfAgent(); if(slaveAgentHandlerOfAgent == NULL) { printError("Couldn't create Slave Agent Handler!"); return false; } return true; } bool Agent :: del_slaveAgentHandlerOfAgent() { if(slaveAgentHandlerOfAgent != NULL) { //TODO: Unmount/delete all SlaveAgentSlots with everything inside (history module, confidence module, ...) delete slaveAgentHandlerOfAgent; return true; } return false; } SlaveAgentHandlerOfAgent* Agent :: get_slaveAgentHandlerOfAgent() { if(slaveAgentHandlerOfAgent == NULL) { set_slaveAgentHandlerOfAgent(); } return slaveAgentHandlerOfAgent; } bool Agent :: set_masterAgentHandlerOfAgent() { masterAgentHandlerOfAgent = new MasterAgentHandlerOfAgent(); if(masterAgentHandlerOfAgent == NULL) { printError("Couldn't create Master Agent Handler!"); return false; } return true; } bool Agent :: del_masterAgentHandlerOfAgent() { if(masterAgentHandlerOfAgent != NULL) { //TODO: Unmount/delete (all) MasterAgentSlot(s) with everything inside delete masterAgentHandlerOfAgent; return true; } return false; } MasterAgentHandlerOfAgent* Agent :: get_masterAgentHandlerOfAgent() { if(masterAgentHandlerOfAgent == NULL) { set_masterAgentHandlerOfAgent(); } return masterAgentHandlerOfAgent; } bool Agent :: set_stateHandler() { stateHandler = new StateHandler(); if(stateHandler == NULL) { printError("Couldn't create Master Agent Handler!"); return false; } return true; } +bool Agent ::set_stateHandler(std::string csvWriterPath) { + stateHandler = new StateHandler(NO_NAME, csvWriterPath); + + if (stateHandler == NULL) { + printError("Couldn't create Master Agent Handler!"); + return false; + } + return true; +} + +bool Agent ::set_stateHandler( + std::string name, std::string csvWriterPath) { + stateHandler = new StateHandler(name, csvWriterPath); + + if (stateHandler == NULL) { + printError("Couldn't create Master Agent Handler!"); + return false; + } + return true; +} + + bool Agent :: set_stateHandler(StateHandler* stateHandler) { if(stateHandler == NULL) { this->stateHandler = stateHandler; return true; } return false; } bool Agent :: del_stateHandler() { if(stateHandler != NULL) { //TODO: Unmount/delete (all) MasterAgentSlot(s) with everything inside delete stateHandler; return true; } return false; } StateHandler* Agent :: get_stateHandler() { if(stateHandler == NULL) { set_stateHandler(); } return stateHandler; } StateHandler* Agent::get_stateHandler2() { return stateHandler; } Agent::~Agent() { del_masterAgentHandlerOfAgent(); del_slaveAgentHandlerOfAgent(); del_sensorHandlerOfAgent(); del_stateHandler(); } void Agent :: trigger(unsigned int cycle) { if (workingCycleCounter < get_workingCycle()) workingCycleCounter++; else workingCycleCounter = 1; if (workingCycleCounter == 1) { //TODO: make control_module to set the method of operating for each agent individual //Job: Read all sensory data if(sensorHandlerOfAgent != NULL) { //printf("%s->sensorHandler: ", name); sensorHandlerOfAgent->read_allSensorValues(); } //Job: Read all slave agent data if(slaveAgentHandlerOfAgent != NULL) { //TODO: do this in HistoryModule //TODO: this for all slots (not only for slaveagents) slaveAgentHandlerOfAgent->saveAllValuesInHistory(); //getchar(); slaveAgentHandlerOfAgent->read_allSlaveAgentValues(); } //Job: Just pass the Sensory Data (without abstraction) to master if(masterAgentHandlerOfAgent != NULL) { if(sensorHandlerOfAgent != NULL) { vector* vSensoryData = sensorHandlerOfAgent->get_vMountedSensors(); for(auto &sensorSlot : *vSensoryData) { //TODO: also for int float sensorValue; if(sensorSlot->get_sensorValue(&sensorValue)) { masterAgentHandlerOfAgent->pass_msgToSendBuffer(ISA_SensoryData); masterAgentHandlerOfAgent->pass_msgToSendBuffer(sensorValue); } } } masterAgentHandlerOfAgent->send_msgs(); } if (stateHandler != NULL) { stateHandler->trigger(cycle); } } - /* - read_all_mountedSensors(); - - validate_confidence_of_all_mountedSensors(); - - //TODO: save only when confident or save everytime? ...maybe safe confidence as meta data. - save_all_mountedSensor_histories(); - - read_all_slaveAgents(); - */ - - - - - - - - - - - - - - - - - - - - - - - - /* OLD - //has to be done in an extra loop because every slave agent values are needed - for(unsigned int sa_ix = 0; sa_ixcross_validate(num_of_mounted_slaveagents, slaveagent_value, &flag_slaveagent_value_confident[0]); - } - } - - - //bunch //TODO: auch f�r integer (slaveagents) - if(flag_bunch_module_exist) { - bunch_score_confidency = bunch_module->bunch(num_of_mounted_slaveagents, &slaveagent_value[0], &flag_slaveagent_value_confident[0], &bunched_score); - //printf("flag_bunched_score_exist setzten - "); - if(bunch_score_confidency > 0) { - flag_bunched_score_exist = true; - //printf("true\n"); - } - else { - flag_bunched_score_exist = false; - //printf("false\n"); - } - } - - - - - - - //abstract data //TODO: auch f�r integer (slaveagents) - for(unsigned int s_ix = 0; s_ixabstract(sensor_value[s_ix], &abstracted_sensor_score[s_ix])) { - flag_abstracted_sensor_score_exist[s_ix] = true; - } - else { - flag_abstracted_sensor_score_exist[s_ix] = false; - } - } - } - } - - //sending data / do specific task - if(flag_masteragent_outputport_is_active) { - for(unsigned int s_ix = 0; s_ixset_msg((int)ISA_SCORE_VALID); - } - else { - mounted_masteragent_outputport->set_msg((int)ISA_SCORE_INVALID); - } - } - else { - mounted_masteragent_outputport->set_msg((int)ISA_SCORE_VALID); - } - - - - //if(flag_sensor_value_confident || flag_confidence_validator_exist == false) { - // mounted_masteragent_outputport->set_msg((int)IS_SCORE_VALID); - //} - //else { - // mounted_masteragent_outputport->set_msg((int)IS_SCORE_INVALID); - //} - - mounted_masteragent_outputport->set_msg(abstracted_sensor_score[s_ix]); - } - } - } - */ -} - - - -/* -void Agent :: initialize_master_slot() { - //TODO: also mast_is_active needed? - flag_masteragent_is_mounted = UNMOUNTED; - flag_masteragent_inputport_is_active = INACTIVE; - flag_masteragent_outputport_is_active = INACTIVE; -} - -void Agent :: initialize_slaveagent_slots() { - num_of_mounted_slaveagents = 0; - //number_of_active_mounted_subagents = 0; //TODO: do i need it?? - for(unsigned int sa_ix=0; sa_ixworking_frequency = working_frequency; - return true; - } - this->working_frequency = 0; - return false; -} - - -bool Agent :: read_mountedSensor(unsigned int s_ix) { - - bool flag_got_new_sensor_value; - float temp_sensor_value; - - flag_got_new_sensor_value = mounted_sensor_inputport[s_ix]->get_msg_float(&temp_sensor_value); - - if(flag_got_new_sensor_value) { - - if(!flag_sensor_value_set[s_ix]) { - flag_sensor_value_set[s_ix] = true; - flag_sensor_value_changed[s_ix] = true; - sensor_value[s_ix] = temp_sensor_value; - } - else { - if(sensor_value[s_ix] == temp_sensor_value) { - flag_sensor_value_changed[s_ix] = false; - } - else { - flag_sensor_value_changed[s_ix] = true; - sensor_value[s_ix] = temp_sensor_value; - } - } - } - else { - flag_sensor_value_changed[s_ix] = false; - } - - return flag_got_new_sensor_value; -} - - -void Agent :: read_all_mountedSensors() { - - for(unsigned int s_ix = 0; s_ixdrop_data(sensor_value[s_ix]); - } - - return flag_data_saved; } -void Agent :: save_all_mountedSensor_histories() { - for(unsigned int s_ix = 0; s_ixget_latest_value(&temp_value)) - printf("History %s got value: %f\n", name, temp_value); - else - printf("History %s got no value.\n", name); - } - else { - printf("History doesn't exist.\n"); - } - } -} -//TODO: this function is untested - test it! -bool Agent :: validate_confidence_of_mountedSensor(unsigned int s_ix) { - - if(flag_sensor_value_set[s_ix]) { - - if(flag_confidence_validator_exist[s_ix]) { - //TODO: modify validate_confidence function in a way that there is parameter that says if actual sensor_value[s_ix] is already in history or not! - flag_sensor_value_confident[s_ix] = list_of_confidence_validators[s_ix]->validate_confidence(sensor_value[s_ix], sensor_history[s_ix]); - } - else { - //I have to believe it if I don't know - flag_sensor_value_confident[s_ix] = true; - } - } - - return flag_sensor_value_confident[s_ix]; -} - -void Agent :: validate_confidence_of_all_mountedSensors() { - for(unsigned int s_ix = 0; s_ixis_there_a_msg_for_me_int()) { - - instruction = mounted_slaveagent_inputport[sa_ix]->get_msg_int(); //TODO: hier (vllt) auch die m�glichkeit float (score) einzulesen!! - - if(instruction == ISA_SCORE_VALID || instruction == ISA_SCORE_INVALID) { - - bool got_msg = mounted_slaveagent_inputport[sa_ix]->is_there_a_msg_for_me_int(); - - if(got_msg) { - data = mounted_slaveagent_inputport[sa_ix]->get_msg_int(); - - if(slaveagent_value[sa_ix] != data) { - flag_slaveagent_value_changed[sa_ix] = true; - } - slaveagent_value[sa_ix] = data; - flag_slaveagent_value_set[sa_ix] = true; - - if(instruction == ISA_SCORE_VALID) { - //if(id == 0) - // printf("setze valid\n"); - flag_slaveagent_value_confident[sa_ix] = true; - } - else { - //if(id == 0) - // printf("setze invalid\n"); - flag_slaveagent_value_confident[sa_ix] = false; - } - } - else { - flag_slaveagent_value_set[sa_ix] = false; - } - } else { - flag_slaveagent_value_set[sa_ix] = false; - } - } - //TODO: do i need a return value? - return false; -} - -void Agent :: read_all_slaveAgents() { - for(unsigned int sa_ix = 0; sa_ixcross_validate(num_of_mounted_slaveagents, slaveagent_value, &flag_slaveagent_value_confident[0]); - } - } - - - //bunch //TODO: auch f�r integer (slaveagents) - if(flag_bunch_module_exist) { - bunch_score_confidency = bunch_module->bunch(num_of_mounted_slaveagents, &slaveagent_value[0], &flag_slaveagent_value_confident[0], &bunched_score); - //printf("flag_bunched_score_exist setzten - "); - if(bunch_score_confidency > 0) { - flag_bunched_score_exist = true; - //printf("true\n"); - } - else { - flag_bunched_score_exist = false; - //printf("false\n"); - } - } - - - - - - - //abstract data //TODO: auch f�r integer (slaveagents) - for(unsigned int s_ix = 0; s_ixabstract(sensor_value[s_ix], &abstracted_sensor_score[s_ix])) { - flag_abstracted_sensor_score_exist[s_ix] = true; - } - else { - flag_abstracted_sensor_score_exist[s_ix] = false; - } - } - } - } - - //sending data / do specific task - if(flag_masteragent_outputport_is_active) { - for(unsigned int s_ix = 0; s_ixset_msg((int)ISA_SCORE_VALID); - } - else { - mounted_masteragent_outputport->set_msg((int)ISA_SCORE_INVALID); - } - } - else { - mounted_masteragent_outputport->set_msg((int)ISA_SCORE_VALID); - } - - - - //if(flag_sensor_value_confident || flag_confidence_validator_exist == false) { - // mounted_masteragent_outputport->set_msg((int)IS_SCORE_VALID); - //} - //else { - // mounted_masteragent_outputport->set_msg((int)IS_SCORE_INVALID); - //} - - mounted_masteragent_outputport->set_msg(abstracted_sensor_score[s_ix]); - } - } - } - */ -/*} - - -//TODO: prevent possibility to mount yourself as subagent! -//TODO: prevent possibility to mount sensor as subagent! -bool Agent :: mount_slaveagent(Channel* inputport, Channel* outputport) { - if(num_of_mounted_slaveagents < MAX_NUM_OF_MOUNTED_SLAVEAGENTS && (inputport != NULL || outputport != NULL)) { - for(unsigned int sa_ix=0; sa_ixset_proband(sa_ix); - - num_of_mounted_slaveagents++; - return true; - } - } - } - return false; -} - - - -//TODO: prevent possibility to mount yourself as subagent! -//TODO: prevent possibility to mount subagent as sensor! -bool Agent :: mount_masteragent(Channel* inputport, Channel* outputport) { - if(inputport != NULL || outputport != NULL) { - - if(inputport != NULL) { - mounted_masteragent_inputport = inputport; - flag_masteragent_inputport_is_active = ACTIVE; - } - else { - flag_masteragent_inputport_is_active = INACTIVE; - } - - if(outputport != NULL) { - mounted_masteragent_outputport = outputport; - flag_masteragent_outputport_is_active = ACTIVE; - } - else { - flag_masteragent_outputport_is_active = INACTIVE; - } - - return true; - } - return false; -} - - -bool Agent :: mount_sensor(Channel* inputport, unsigned int position) { - if(position < MAX_NUM_OF_MOUNTED_SENSORS) { - if(flag_sensor_has_dedicated_position[position] == NO && inputport != NULL) { - if(flag_sensor_is_mounted[position] == MOUNTED) { - if(num_of_mounted_sensors < MAX_NUM_OF_MOUNTED_SENSORS) { - for(unsigned int s_ix=0; s_ixbunch_module = bunch_module; - this->flag_bunch_module_exist = true; - return true; - } - return false; -} - - -bool Agent :: get_flag_abstracted_sensor_score_exist(unsigned int position) { - return flag_abstracted_sensor_score_exist[position]; -} - -//TODO: r�ckgabewert, wenn kein vern�nftiger wert -int Agent :: get_abstracted_sensor_score(unsigned int position) { - if(position < num_of_mounted_sensors && flag_abstracted_sensor_score_exist[position]) { - return abstracted_sensor_score[position]; - } - return -1; -} - -bool Agent :: get_flag_bunched_score_exist() { - return flag_bunched_score_exist; -} - -int Agent :: get_bunched_score() { - if(flag_bunched_score_exist) { - return bunched_score; - } - return -1; -} - -unsigned int Agent :: get_bunch_score_confidency() { - return bunch_score_confidency; -} - - - - - - -void Agent :: test_print_all_slaveagents() { - - for(int i=0; iname, mounted_slaveagent_inputport[i]->get_name(), i); - } - if(flag_slaveagent_outputport_is_active[i]) { - printf("%s has mounted %s on position %i\n", this->name, mounted_slaveagent_outputport[i]->get_name(), i); - } - } - else { - printf("%s has nothing mounted on position %i\n", this->name, i); - } - } - getchar(); -} - -void Agent :: test_print_all_sensors() { - - for(int i=0; iname, mounted_sensor_inputport[i]->get_name(), i); - } - } - else { - printf("%s has nothing mounted on position %i\n", this->name, i); - } - } - getchar(); -} -*/ diff --git a/Version_Max_07_05_2018_CMake/src/Agent.h b/Version_Max_07_05_2018_CMake/src/Agent.h index dd0b42d..d498da3 100755 --- a/Version_Max_07_05_2018_CMake/src/Agent.h +++ b/Version_Max_07_05_2018_CMake/src/Agent.h @@ -1,208 +1,211 @@ #ifndef AGENT_HEADERFILE #define AGENT_HEADERFILE #include "MasterAgentHandlerOfAgent.h" #include "Node.h" #include "SensorHandlerOfAgent.h" #include "SlaveAgentHandlerOfAgent.h" #include "StateHandler.h" #include class Agent : public Node { private : SensorHandlerOfAgent* sensorHandlerOfAgent; SlaveAgentHandlerOfAgent* slaveAgentHandlerOfAgent; MasterAgentHandlerOfAgent* masterAgentHandlerOfAgent; /// Pointer to the stateHandler StateHandler* stateHandler; unsigned int workingCycleCounter; void init_agent(); public: Agent(); - Agent(char* name); + Agent(string name); bool set_sensorHandlerOfAgent(); bool del_sensorHandlerOfAgent(); SensorHandlerOfAgent* get_sensorHandlerOfAgent(); bool set_slaveAgentHandlerOfAgent(); bool del_slaveAgentHandlerOfAgent(); SlaveAgentHandlerOfAgent* get_slaveAgentHandlerOfAgent(); bool set_masterAgentHandlerOfAgent(); bool del_masterAgentHandlerOfAgent(); MasterAgentHandlerOfAgent* get_masterAgentHandlerOfAgent(); bool set_stateHandler(); + bool set_stateHandler(std::string csvWriterPath); + bool set_stateHandler(std::string name, + std::string csvWriterPath); bool set_stateHandler(StateHandler* stateHandler); bool del_stateHandler(); StateHandler* get_stateHandler(); StateHandler* get_stateHandler2(); void trigger(unsigned int cycle); bool operator !=(const Agent& a) { - return strcmp(this->name, a.name); + return strcmp(this->name.c_str(), a.name.c_str()); } ~Agent(); /* private: unsigned int working_frequency; //master agent bool flag_masteragent_is_mounted; Channel* mounted_masteragent_inputport; Channel* mounted_masteragent_outputport; bool flag_masteragent_inputport_is_active; bool flag_masteragent_outputport_is_active; //slave agents unsigned int num_of_mounted_slaveagents; bool flag_slaveagent_is_mounted[MAX_NUM_OF_MOUNTED_SLAVEAGENTS]; bool flag_slaveagent_has_dedicated_position[MAX_NUM_OF_MOUNTED_SLAVEAGENTS]; Channel* mounted_slaveagent_inputport[MAX_NUM_OF_MOUNTED_SLAVEAGENTS]; Channel* mounted_slaveagent_outputport[MAX_NUM_OF_MOUNTED_SLAVEAGENTS]; bool flag_slaveagent_inputport_is_active[MAX_NUM_OF_MOUNTED_SLAVEAGENTS]; bool flag_slaveagent_outputport_is_active[MAX_NUM_OF_MOUNTED_SLAVEAGENTS]; //slaveagent values int slaveagent_value[MAX_NUM_OF_MOUNTED_SENSORS]; bool flag_slaveagent_value_set[MAX_NUM_OF_MOUNTED_SENSORS]; bool flag_slaveagent_value_changed[MAX_NUM_OF_MOUNTED_SENSORS]; //sensors unsigned int num_of_mounted_sensors; bool flag_sensor_is_mounted[MAX_NUM_OF_MOUNTED_SENSORS]; bool flag_sensor_has_dedicated_position[MAX_NUM_OF_MOUNTED_SENSORS]; Channel* mounted_sensor_inputport[MAX_NUM_OF_MOUNTED_SENSORS]; bool flag_sensor_inputport_is_active[MAX_NUM_OF_MOUNTED_SENSORS]; //sensor values float sensor_value[MAX_NUM_OF_MOUNTED_SENSORS]; bool flag_sensor_value_set[MAX_NUM_OF_MOUNTED_SENSORS]; bool flag_sensor_value_changed[MAX_NUM_OF_MOUNTED_SENSORS]; //sensor history HistoryModule* sensor_history[MAX_NUM_OF_MOUNTED_SENSORS]; bool flag_sensor_history_exist[MAX_NUM_OF_MOUNTED_SENSORS]; //confidence bool flag_confidence_validator_exist[MAX_NUM_OF_MOUNTED_SENSORS]; ConfidenceModule* list_of_confidence_validators[MAX_NUM_OF_MOUNTED_SENSORS]; bool flag_sensor_value_confident[MAX_NUM_OF_MOUNTED_SENSORS]; bool flag_slaveagent_value_confident[MAX_NUM_OF_MOUNTED_SLAVEAGENTS]; //abstraction modules bool flag_abstraction_exist[MAX_NUM_OF_MOUNTED_SENSORS]; AbstractionModule* list_of_abstractions[MAX_NUM_OF_MOUNTED_SENSORS]; int abstracted_sensor_score[MAX_NUM_OF_MOUNTED_SENSORS]; bool flag_abstracted_sensor_score_exist[MAX_NUM_OF_MOUNTED_SENSORS]; //bunch module bool flag_bunch_module_exist; Bunch_Module* bunch_module; int bunched_score; bool flag_bunched_score_exist; unsigned int bunch_score_confidency; //private functions void initialize_master_slot(); void initialize_slaveagent_slots(); void initialize_sensor_slots(); void initialize_bunch_module(); void initialize_working_frequency(int* success_indicator); //cross confidence Cross_Confidence_Validator* list_of_ccv_modules[MAX_NUM_OF_MOUNTED_SLAVEAGENTS]; bool flag_ccv_module_exist[MAX_NUM_OF_MOUNTED_SLAVEAGENTS]; bool read_mountedSensor(unsigned int s_ix); void read_all_mountedSensors(); bool save_mountedSensor_history(unsigned int s_ix); void save_all_mountedSensor_histories(); bool validate_confidence_of_mountedSensor(unsigned int s_ix); void validate_confidence_of_all_mountedSensors(); bool read_slaveAgent(unsigned int sa_ix); void read_all_slaveAgents(); public: // ----- Standard Attributes ----- Agent(); Agent(char* name); Agent(unsigned int working_frequency, int* success_indicator); Agent(char* name, unsigned int working_frequency, int* success_indicator); bool set_working_frequency(unsigned int working_frequency); // ----- Runtime Functions ----- void trigger(); // ----- Setup Subagents ----- bool mount_slaveagent(Channel* inputport, Channel* outputport); bool mount_slaveagent(Channel* inputport, Channel* outputport, unsigned int position); bool mount_slaveagent(Channel* inputport, Channel* outputport, Cross_Confidence_Validator* ccv); bool mount_masteragent(Channel* inputport, Channel* outputport); // ----- Setup Mounted Sensors ----- bool mount_sensor(Channel* inputport); bool mount_sensor(Channel* inputport, unsigned int position); bool mount_sensor(Channel* inputport, Abstraction* abstraction); bool mount_sensor(Channel* inputport, Confidence_Validator* confidence_validator); bool mount_sensor(Channel* inputport, HistoryModule* historyModule); bool mount_sensor(Channel* inputport, Confidence_Validator* confidence_validator, Abstraction* abstraction); // ----- Bunch Module ----- bool mount_bunch_module(Bunch_Module* bunch_module); // ----- Setup Abstraction Method ----- //bool set_abstraction_method(unsigned int abstraction_method); //unsigned int get_abstraction_method(); //void set_agent_id(unsigned int id); //unsigned int get_agent_id(); // ----- Setup Agent ----- //TODO: DEACTIVATE, ACTIVATE (muss auch in miunt funktion an den Subagent weitergegeben werden) void set_active_state_flag(bool flag); bool get_active_state_flag(); void set_master_agent(Agent* agent); void Agent :: register_as_master_agent(Agent* agent); void Agent :: deregister_as_master_agent(); Agent* get_master_agent(); bool get_flag_abstracted_sensor_score_exist(unsigned int position); int get_abstracted_sensor_score(unsigned int position); bool get_flag_bunched_score_exist(); int get_bunched_score(); unsigned int get_bunch_score_confidency(); //test functions void test_print_all_slaveagents(); void test_print_all_sensors(); */ }; #endif diff --git a/Version_Max_07_05_2018_CMake/src/CSV_Writer.cpp b/Version_Max_07_05_2018_CMake/src/CSV_Writer.cpp index 85ef914..91b88a9 100755 --- a/Version_Max_07_05_2018_CMake/src/CSV_Writer.cpp +++ b/Version_Max_07_05_2018_CMake/src/CSV_Writer.cpp @@ -1,104 +1,112 @@ #include "CSV_Writer.h" //#include //#include #define STRINGLENGTH 5000 -void CSV_Writer :: initialize_csv_writer(const char* filepath_write) { +void CSV_Writer ::initialize_csv_writer(std::string filepath_write) { //printf("init ... %s\n", filepath_write); if(!this->valid_fp) { - this->fpointer_write = fopen(filepath_write, "w"); - //fopen_s(&fpointer_write, filepath_write, "w"); +#ifdef _WIN32 + fopen_s(&fpointer_write, filepath_write.c_str(), "w"); +#else + this->fpointer_write = fopen(filepath_write.c_str(), "w"); +#endif + }else { close_file(); - this->fpointer_write = fopen(filepath_write, "w"); +#ifdef _WIN32 + fopen_s(&(this->fpointer_write), filepath_write.c_str(), "w"); +#else + this->fpointer_write = fopen(filepath_write.c_str(), "w"); +#endif } if(this->fpointer_write != nullptr){ this->valid_fp = true; } } -CSV_Writer :: CSV_Writer(char* filepath_write) { +CSV_Writer ::CSV_Writer(std::string filepath_write) { CSV_Writer(NO_NAME, filepath_write); } -CSV_Writer :: CSV_Writer(char* name, char* filepath_write) { +CSV_Writer ::CSV_Writer(std::string name, std::string filepath_write) { this->valid_fp = false; set_name(name); initialize_csv_writer(filepath_write); } bool CSV_Writer :: write_field(int dataset) { if(fpointer_write) { fprintf(fpointer_write, "%i", dataset); return true; } return false; } bool CSV_Writer :: write_field(float dataset) { if(fpointer_write) { fprintf(fpointer_write, "%f", dataset); return true; } return false; } -bool CSV_Writer :: write_field(char* dataset) { +bool CSV_Writer :: write_field(std::string dataset) { if(fpointer_write) { - fprintf(fpointer_write, "%s", dataset); + fprintf(fpointer_write, "%s", dataset.c_str()); return true; } return false; } bool CSV_Writer :: make_new_field() { if(fpointer_write) { fprintf(fpointer_write, ","); return true; } return false; } bool CSV_Writer :: make_new_line() { if(fpointer_write) { fprintf(fpointer_write, "\n"); return true; } return false; } bool CSV_Writer :: write_row_data(unsigned int num_of_datasets, float* datasets) { if(fpointer_write) { for(unsigned int d_ix=0; d_ixvalid_fp = false; } } CSV_Writer :: ~CSV_Writer() { } diff --git a/Version_Max_07_05_2018_CMake/src/CSV_Writer.h b/Version_Max_07_05_2018_CMake/src/CSV_Writer.h index 03f0d2f..50bb786 100755 --- a/Version_Max_07_05_2018_CMake/src/CSV_Writer.h +++ b/Version_Max_07_05_2018_CMake/src/CSV_Writer.h @@ -1,40 +1,40 @@ #ifndef CSV_WRITER_HEADERFILE #define CSV_WRITER_HEADERFILE #include "Module.h" #include #include #define MAX_LENGTH_OF_NAMES_TO_WRITE 50 class CSV_Writer : public Module { private: FILE *fpointer_write; - unsigned int num_of_datasets; - float datasets[MAX_NUM_OF_DATA_SETS]; + //unsigned int num_of_datasets; + //float datasets[MAX_NUM_OF_DATA_SETS]; bool valid_fp; - void initialize_csv_writer(const char* filepath_write); + void initialize_csv_writer(std::string filepath_write); public: - CSV_Writer(char* filepath_write); - CSV_Writer(char* name, char* filepath_write); + CSV_Writer(std::string filepath_write); + CSV_Writer(std::string name, std::string filepath_write); bool write_field(int dataset); bool write_field(float dataset); - bool write_field(char* dataset); + bool write_field(std::string dataset); bool make_new_field(); bool make_new_line(); bool write_row_data(unsigned int num_of_datasets, float* datasets); void reset_fpointer(std::string filepath_write); void close_file(); ~CSV_Writer(); }; #endif diff --git a/Version_Max_07_05_2018_CMake/src/CSVreaderModule.cpp b/Version_Max_07_05_2018_CMake/src/CSVreaderModule.cpp index f652c26..79ca0a1 100755 --- a/Version_Max_07_05_2018_CMake/src/CSVreaderModule.cpp +++ b/Version_Max_07_05_2018_CMake/src/CSVreaderModule.cpp @@ -1,235 +1,236 @@ #include "CSVreaderModule.h" #include "file_util.h" #include #include #include #define STRINGLENGTH 5000 /* void CSV_Reader :: initialize_csvreader(char* filepath_read, unsigned int num_of_datasets, unsigned int* list_of_datasets, unsigned int start_row) { //fpointer_read = fopen(filepath_read, "r"); fopen_s(&fpointer_read, filepath_read, "r"); this->num_of_datasets = num_of_datasets; //TODO: sort.. falls es nicht in aufsteigender folge kommt for(unsigned int d_ix=0; d_ixlist_of_datasets[d_ix] = list_of_datasets[d_ix]; } row = 1; this->start_row = start_row; } */ void CSVreaderModule :: initialize_csvreader(FILE* fpointer, unsigned int column, unsigned int start_row) { //fpointer_read = fopen(filepath_read, "r"); //TODO: file ponter schon aus CSV-Reader Creator Funktion �bergeben.. dann kann man n�mlich ausgeben, wenn da was nicht erstellt werden kann //bool file_opened = fopen_s(&fpointer_read, filepath_read, "r"); //TODO: etwas mit flag this->fpointer = fpointer; this->row = 1; this->column = column; this->start_row = start_row; flag_csv_reader_configured = true; } /* CSV_Reader :: CSV_Reader(char* filepath_read, unsigned int num_of_data_sets, unsigned int* list_of_datasets, unsigned int start_row) { set_name(NO_NAME); initialize_csvreader(filepath_read, num_of_data_sets, list_of_datasets, start_row); } CSV_Reader :: CSV_Reader(char* name, char* filepath_read, unsigned int num_of_data_sets, unsigned int* list_of_datasets, unsigned int start_row) { set_name(name); initialize_csvreader(filepath_read, num_of_data_sets, list_of_datasets, start_row); } */ CSVreaderModule :: CSVreaderModule() { set_name(NO_NAME); flag_csv_reader_configured = false; } -CSVreaderModule :: CSVreaderModule(char* name) { +CSVreaderModule ::CSVreaderModule(std::string name) { set_name(name); flag_csv_reader_configured = false; } CSVreaderModule :: CSVreaderModule(FILE* fpointer, unsigned int column, unsigned int start_row) { set_name(NO_NAME); if(fpointer) { initialize_csvreader(fpointer, column, start_row); } else { flag_csv_reader_configured = false; } } -CSVreaderModule :: CSVreaderModule(char* name, FILE* fpointer, unsigned int column, unsigned int start_row) { +CSVreaderModule ::CSVreaderModule(std::string name, FILE *fpointer, + unsigned int column, unsigned int start_row) { set_name(name); if(fpointer) { initialize_csvreader(fpointer, column, start_row); } else { flag_csv_reader_configured = false; } } /* CSV_Reader :: CSV_Reader(char* name, char* filepath_read, int column, int start_row) { } */ //XXX: Wird nicht mehr benutzt //TODO: �berarbeiten nach folgendem Beispiel https://msdn.microsoft.com/en-us/library/ftsafwz3.aspx bool CSVreaderModule :: read_one_row() { if(fpointer) { - char readrow[STRINGLENGTH] = "", electedfield[STRINGLENGTH] = ""; + char readrow[STRINGLENGTH] = ""; //TODO: move following for-loop to "initialize_csvreader(...) for(;rowrow = row; } void CSVreaderModule:: set_position_fpointer_to_start() { long int cur_pos; if(this->fpointer) { cur_pos = ftell(this->fpointer); rewind(this->fpointer); } } //TODO: flag_csv_reader_configured abfragen void CSVreaderModule :: close_file() { fclose(fpointer); } CSVreaderModule :: ~CSVreaderModule(){ if(fpointer) { close_file(); } } diff --git a/Version_Max_07_05_2018_CMake/src/CSVreaderModule.h b/Version_Max_07_05_2018_CMake/src/CSVreaderModule.h index 2b1ba30..f07c0c7 100755 --- a/Version_Max_07_05_2018_CMake/src/CSVreaderModule.h +++ b/Version_Max_07_05_2018_CMake/src/CSVreaderModule.h @@ -1,52 +1,53 @@ #ifndef CSV_READER_HEADERFILE #define CSV_READER_HEADERFILE #include "Module.h" #include class CSVreaderModule : public Module { private: FILE *fpointer; unsigned int num_of_datasets; unsigned int list_of_datasets[MAX_NUM_OF_DATA_SETS]; float data_read[MAX_NUM_OF_DATA_SETS]; unsigned int row, start_row, column; float input_data; bool flag_csv_reader_configured; unsigned int dataset_counter; //private fuctions //void initialize_csvreader(char* filepath_read, unsigned int num_of_datasets, unsigned int* list_of_datasets, unsigned int start_row); void initialize_csvreader(FILE* fpointer, unsigned int column, unsigned int start_row); public: CSVreaderModule(); - CSVreaderModule(char* name); + CSVreaderModule(std::string name); CSVreaderModule(FILE* fpointer, unsigned int column, unsigned int start_row); - CSVreaderModule(char* name, FILE* fpointer, unsigned int column, unsigned int start_row); + CSVreaderModule(std::string name, FILE *fpointer, unsigned int column, + unsigned int start_row); /* CSV_Reader(char* filepath_read, unsigned int column, unsigned int start_row); CSV_Reader(char* name, char* filepath_read, unsigned int column, unsigned int start_row); */ bool read_one_row(); bool read_field(); float get_value_of_field(unsigned int field); //new functions bool get_next_value(float* value); void reset_row(const int row); void set_position_fpointer_to_start(); void close_file(); ~CSVreaderModule(); }; #endif diff --git a/Version_Max_07_05_2018_CMake/src/Channel.cpp b/Version_Max_07_05_2018_CMake/src/Channel.cpp index fec8a73..4e95c2b 100755 --- a/Version_Max_07_05_2018_CMake/src/Channel.cpp +++ b/Version_Max_07_05_2018_CMake/src/Channel.cpp @@ -1,350 +1,360 @@ #include "Channel.h" #include #define MAX_BUFFER_LENGTH 100 void Channel :: init_channel() { maxBufferLength = MAX_BUFFER_LENGTH; transferRate = MAX_BUFFER_LENGTH; } Channel :: Channel() { init_channel(); } -Channel :: Channel(char* name) { +Channel :: Channel(std::string name) { set_name(name); init_channel(); } bool Channel :: set_maxBufferLength(unsigned int maxBufferLength) { if(maxBufferLength <= MAX_BUFFER_LENGTH) { this->maxBufferLength = maxBufferLength; return true; } return false; } unsigned int Channel :: get_maxBufferLength() { return maxBufferLength; } unsigned int Channel :: get_avlInputBufferUp() { return maxBufferLength-lInputMsgBufferUp.size(); } unsigned int Channel :: get_avlOutputBufferUp() { return maxBufferLength-lOutputMsgBufferUp.size(); } unsigned int Channel :: get_avlInputBufferDown() { return maxBufferLength-lInputMsgBufferDown.size(); } unsigned int Channel :: get_avlOutputBufferDown() { return maxBufferLength-lOutputMsgBufferDown.size(); } bool Channel :: set_transferRate(unsigned int transferRate) { if(transferRate <= MAX_BUFFER_LENGTH) { this->transferRate = transferRate; return true; } return false; } unsigned int Channel :: get_transferRate() { return transferRate; } bool Channel :: add_msgAtBegin (list* buffer, Message* message) { try { buffer->push_front(message); } catch(bad_alloc& error) { delete message; return false; } return true; } bool Channel :: del_msgAtBegin (list* buffer) { try { /* printf("a\n"); getchar(); delete buffer->back(); printf("b\n"); getchar(); */ Message* first_Message = buffer->front(); delete first_Message; buffer->pop_front(); /* printf("c\n"); getchar(); */ } catch(bad_alloc& error) { return false; } return true; } bool Channel :: add_msgAtEnd (list* buffer, Message* message) { try { buffer->push_back(message); } catch(bad_alloc& error) { cerr << "bad_alloc caught: " << error.what() << endl; delete message; return false; } return true; } bool del_msgAtEnd (list* buffer) { try { Message* last_Message = buffer->back(); delete last_Message; buffer->pop_back(); } catch(bad_alloc& error) { return false; } return true; } bool Channel :: send_MsgUp(Message* message) { if(message != NULL) { if(transferRate == 0) { //TODO: at the moment only one packet (in the front) gets deleted if buffer is full. However, the whole message (instruction+value) should be deleted in case of a full buffer if(lOutputMsgBufferUp.size() == maxBufferLength) { del_msgAtBegin(&lOutputMsgBufferUp); } return add_msgAtEnd(&lOutputMsgBufferUp, message); } else { if(lInputMsgBufferUp.size() == maxBufferLength) { //TODO: at the moment only one packet (in the front) gets deleted if buffer is full. However, the whole message (instruction+value) should be deleted in case of a full buffer del_msgAtBegin(&lInputMsgBufferUp); } return add_msgAtEnd(&lInputMsgBufferUp, message); } } + + //TODO: check if NULL is a good default return value + return NULL; } bool Channel :: send_MsgUp(float msg) { Message* message = new Message(msg); return send_MsgUp(message); } bool Channel :: send_MsgUp(int msg) { Message* message = new Message(msg); return send_MsgUp(message); } bool Channel :: get_MsgUp(float* msg) { if(isThereFloatMsgUp()) { float tempMsg; if(lOutputMsgBufferUp.front()->getMsg(&tempMsg)) { *msg = tempMsg; del_msgAtBegin(&lOutputMsgBufferUp); return true; } } return false; } bool Channel :: get_MsgUp(int* msg) { if(isThereIntMsgUp()) { int tempMsg; if(lOutputMsgBufferUp.front()->getMsg(&tempMsg)) { *msg = tempMsg; del_msgAtBegin(&lOutputMsgBufferUp); return true; } } return false; } bool Channel :: isThereFloatMsgUp() { if(lOutputMsgBufferUp.size() > 0 ) { if(lOutputMsgBufferUp.front() != NULL) { return lOutputMsgBufferUp.front()->isMsgFloat(); } } return false; } bool Channel :: isThereIntMsgUp() { if(lOutputMsgBufferUp.size() > 0 ) { if(lOutputMsgBufferUp.front() != NULL) { return lOutputMsgBufferUp.front()->isMsgInt(); } } return false; } bool Channel :: send_MsgDown(Message* message) { if(message != NULL) { if(transferRate == 0) { if(lOutputMsgBufferDown.size() == maxBufferLength) { del_msgAtBegin(&lOutputMsgBufferDown); } return add_msgAtEnd(&lOutputMsgBufferDown, message); } else { if(lInputMsgBufferDown.size() == maxBufferLength) { del_msgAtBegin(&lInputMsgBufferDown); } return add_msgAtEnd(&lInputMsgBufferDown, message); } } + + // TODO: check if NULL is a good default return value + return NULL; } bool Channel :: send_MsgDown(float msg) { Message* message = new Message(msg); return send_MsgDown(message); } bool Channel :: send_MsgDown(int msg) { Message* message = new Message(msg); return send_MsgDown(message); } bool Channel :: get_MsgDown(float* msg) { if(isThereFloatMsgDown()) { float tempMsg; if(lOutputMsgBufferDown.front()->getMsg(&tempMsg)) { *msg = tempMsg; del_msgAtBegin(&lOutputMsgBufferDown); return true; } } return false; } bool Channel :: get_MsgDown(int* msg) { if(isThereIntMsgDown()) { int tempMsg; if(lOutputMsgBufferDown.front()->getMsg(&tempMsg)) { *msg = tempMsg; del_msgAtBegin(&lOutputMsgBufferDown); return true; } } return false; } bool Channel :: isThereFloatMsgDown() { if(lOutputMsgBufferDown.size() > 0 ) { if(lOutputMsgBufferDown.front() != NULL) { return lOutputMsgBufferDown.front()->isMsgFloat(); } } return false; } bool Channel :: isThereIntMsgDown() { if(lOutputMsgBufferDown.size() > 0 ) { if(lOutputMsgBufferDown.front() != NULL) { return lOutputMsgBufferDown.front()->isMsgInt(); } } return false; } bool Channel :: transferMsgs(list* dest_buffer, list* src_buffer) { unsigned int NumOfMsgsToMove; if(transferRate <= src_buffer->size()) { NumOfMsgsToMove = transferRate; } else { NumOfMsgsToMove = src_buffer->size(); } if(NumOfMsgsToMove <= maxBufferLength-dest_buffer->size()) { for(unsigned int i=0; ifront())) { if(!del_msgAtBegin(src_buffer)) { return false; } } else { return false; } } return true; } return false; } bool Channel :: trigger() { bool flag_worked = transferMsgs(&lOutputMsgBufferUp, &lInputMsgBufferUp) && transferMsgs(&lOutputMsgBufferUp, &lInputMsgBufferUp); //printf("Channel %s: in_up %u, out_up %u, in_dn %u, out_dn %u,\n", name, lInputMsgBufferUp.size(), lOutputMsgBufferUp.size(), lInputMsgBufferDown.size(), lOutputMsgBufferDown.size()); return flag_worked; } bool Channel :: delete_all_InputMsgBufferUp() { Message* cur_Message; unsigned int cur_index_Message = 0; unsigned int size_li_Inp_MsgBufUp = lInputMsgBufferUp.size(); - for(cur_index_Message = 0; cur_index_Message < size_li_Inp_MsgBufUp; cur_index_Message){ + //changed - "cur_index_Message" to "cur_index_Message++" .. is it right? + for(cur_index_Message = 0; cur_index_Message < size_li_Inp_MsgBufUp; cur_index_Message++){ cur_Message = lInputMsgBufferUp.front(); delete cur_Message; lInputMsgBufferUp.pop_front(); } return true; //added by Ali, it is an error in VS. } bool Channel :: delete_all_OuputMsgBufferUp() { Message* cur_Message; unsigned int cur_index_Message = 0; unsigned int size_li_Out_MsgBufUp = lOutputMsgBufferUp.size(); - for(cur_index_Message = 0; cur_index_Message < size_li_Out_MsgBufUp; cur_index_Message){ + //changed - "cur_index_Message" to "cur_index_Message++" .. is it right? + for(cur_index_Message = 0; cur_index_Message < size_li_Out_MsgBufUp; cur_index_Message++){ cur_Message = lOutputMsgBufferUp.front(); delete cur_Message; lOutputMsgBufferUp.pop_front(); } return true; //added by Ali, it is an error in VS. } bool Channel :: delete_all_InputMsgBufferDown() { Message* cur_Message; unsigned int cur_index_Message = 0; unsigned int size_li_Out_MsgBufDown = lInputMsgBufferDown.size(); - for(cur_index_Message = 0; cur_index_Message < size_li_Out_MsgBufDown; cur_index_Message){ + // changed - "cur_index_Message" to "cur_index_Message++" .. is it right? + for(cur_index_Message = 0; cur_index_Message < size_li_Out_MsgBufDown; cur_index_Message++){ cur_Message = lInputMsgBufferDown.front(); delete cur_Message; lInputMsgBufferDown.pop_front(); } return true; //added by Ali, it is an error in VS. } bool Channel :: delete_all_OutputMsgBufferDown() { Message* cur_Message; unsigned int cur_index_Message = 0; unsigned int size_li_Out_MsgBufDown = lOutputMsgBufferDown.size(); - for(cur_index_Message = 0; cur_index_Message < size_li_Out_MsgBufDown; cur_index_Message){ + //changed - "cur_index_Message" to "cur_index_Message++" .. is it right? + for(cur_index_Message = 0; cur_index_Message < size_li_Out_MsgBufDown; cur_index_Message++){ cur_Message = lOutputMsgBufferDown.front(); delete cur_Message; lOutputMsgBufferDown.pop_front(); } return true; //added by Ali, it is an error in VS. } Channel :: ~Channel() { delete_all_InputMsgBufferUp(); delete_all_OuputMsgBufferUp(); delete_all_InputMsgBufferDown(); delete_all_OutputMsgBufferDown(); } diff --git a/Version_Max_07_05_2018_CMake/src/Channel.h b/Version_Max_07_05_2018_CMake/src/Channel.h index 9139038..7cb56ad 100755 --- a/Version_Max_07_05_2018_CMake/src/Channel.h +++ b/Version_Max_07_05_2018_CMake/src/Channel.h @@ -1,81 +1,81 @@ #ifndef CHANNEL_HEADERFILE #define CHANNEL_HEADERFILE #include #include #include #include "Message.h" #include "Module.h" #define MAX_BUFFER_LENGTH 100 #define OPEN NULL using namespace std; class Channel : public Module { private: list lInputMsgBufferUp; list lOutputMsgBufferUp; list lInputMsgBufferDown; list lOutputMsgBufferDown; unsigned int maxBufferLength; unsigned int transferRate; void init_channel(); bool add_msgAtBegin (list* buffer, Message* message); bool del_msgAtBegin (list* buffer); bool add_msgAtEnd (list* buffer, Message* message); bool del_msgAtEnd (list* buffer); bool delete_all_InputMsgBufferUp(); bool delete_all_OuputMsgBufferUp(); bool delete_all_InputMsgBufferDown(); bool delete_all_OutputMsgBufferDown(); public: Channel(); - Channel(char* name); + Channel(std::string name); bool set_maxBufferLength(unsigned int maxBufferLength); unsigned int get_maxBufferLength(); unsigned int get_avlInputBufferUp(); unsigned int get_avlOutputBufferUp(); unsigned int get_avlInputBufferDown(); unsigned int get_avlOutputBufferDown(); bool set_transferRate(unsigned int transferRate); unsigned int get_transferRate(); bool send_MsgUp(Message* message); bool send_MsgUp(float msg); bool send_MsgUp(int msg); bool get_MsgUp(float* msg); bool get_MsgUp(int* msg); bool isThereFloatMsgUp(); bool isThereIntMsgUp(); bool send_MsgDown(Message* message); bool send_MsgDown(float msg); bool send_MsgDown(int msg); bool get_MsgDown(float* msg); bool get_MsgDown(int* msg); bool isThereFloatMsgDown(); bool isThereIntMsgDown(); bool trigger(); bool transferMsgs(list* dest_buffer, list* src_buffer); ~Channel(); }; #endif diff --git a/Version_Max_07_05_2018_CMake/src/ConfidenceModule.cpp b/Version_Max_07_05_2018_CMake/src/ConfidenceModule.cpp index 5d9548a..3d2ea9d 100755 --- a/Version_Max_07_05_2018_CMake/src/ConfidenceModule.cpp +++ b/Version_Max_07_05_2018_CMake/src/ConfidenceModule.cpp @@ -1,167 +1,168 @@ #include "ConfidenceModule.h" #include "HistoryModule.h" #include //TODO: at the moment are only positive rates_of_changes allowed!! void ConfidenceModule :: initialize_confidence_validator(float lower_bound, bool flag_lower_bound_exist, float upper_bound, bool flag_upper_bound_exist, float rates_of_change, bool flag_rates_of_change_exist) { //plausibility if(lower_bound <= upper_bound) { this->lower_bound = lower_bound; this->upper_bound = upper_bound; this->flag_lower_bound_exist = flag_lower_bound_exist; this->flag_upper_bound_exist = flag_upper_bound_exist; } else { this->lower_bound = upper_bound; this->upper_bound = lower_bound; this->flag_lower_bound_exist = flag_upper_bound_exist; this->flag_upper_bound_exist = flag_lower_bound_exist; } //consistency this->rates_of_change = rates_of_change; this->flag_rates_of_change_exist = flag_rates_of_change_exist; flag_value_got_inconsistence = false; //TODO: Changes of Other Sensors (e.g. Environment Temperature Sensor) } ConfidenceModule :: ConfidenceModule(float lower_bound, bool flag_lower_bound_exist, float upper_bound, bool flag_upper_bound_exist, float rates_of_change, bool flag_rates_of_change_exist) { set_name(NO_NAME); initialize_confidence_validator(lower_bound, flag_lower_bound_exist, upper_bound, flag_upper_bound_exist, rates_of_change, flag_rates_of_change_exist); } ConfidenceModule :: ConfidenceModule(char* name, float lower_bound, bool flag_lower_bound_exist, float upper_bound, bool flag_upper_bound_exist, float rates_of_change, bool flag_rates_of_change_exist) { set_name(name); initialize_confidence_validator(lower_bound, flag_lower_bound_exist, upper_bound, flag_upper_bound_exist, rates_of_change, flag_rates_of_change_exist); } bool ConfidenceModule :: validate_confidence(float input, HistoryModule* historyModule) { bool flag_confidence = true; //bounds if(flag_lower_bound_exist && input < lower_bound) { flag_confidence = false; //printf("lb\ninput = %f\n", input); } if(flag_upper_bound_exist && input > upper_bound) { flag_confidence = false; //printf("ub\n"); } //rates_of_change - float trend_abs; + //TODO: is 0.0 a good initit value?? + float trend_abs = 0.0; //TODO: time_unites and time_base should be configurable and saved for the object - unsigned int time_units = 2; + //unsigned int time_units = 2; bool got_trend = false; //XXX historyModule->get_history_trend_absolutely(&trend_abs, time_units, TB_SECONDS); if(got_trend) { if(trend_abs > rates_of_change) { flag_confidence = false; //printf("trend\n"); //VERSUCH if(flag_value_got_inconsistence == false) { //printf("setze flag\n"); flag_value_got_inconsistence = true; value_before_value_got_inconsistence = 0; //XXX historyModule->get_value_ago(time_units); } } } else { //printf("no trend\n"); } if(flag_value_got_inconsistence) { //TODO: nicht hardcoded float seconds = 20; //printf("tradition\n"); if(input == value_before_value_got_inconsistence) { flag_value_got_inconsistence = false; } else if(input < value_before_value_got_inconsistence) { if(input >= value_before_value_got_inconsistence-rates_of_change*seconds) { flag_value_got_inconsistence = false; } else { flag_confidence = false; } } else if(input > value_before_value_got_inconsistence) { if(input <= value_before_value_got_inconsistence+rates_of_change*seconds) { flag_value_got_inconsistence = false; } else { flag_confidence = false; } } else { flag_confidence = false; } } confidence = flag_confidence; return confidence; } bool ConfidenceModule :: get_confidence() { return confidence; } void ConfidenceModule :: set_lower_bound(float lower_bound) { this->lower_bound = lower_bound; } float ConfidenceModule :: get_lower_bound() { return lower_bound; } void ConfidenceModule :: set_flag_lower_bound_exist(bool flag) { this->flag_lower_bound_exist = flag; } bool ConfidenceModule :: get_flag_lower_bound_exist() { return flag_lower_bound_exist; } void ConfidenceModule :: set_upper_bound(float upper_bound) { this->upper_bound = upper_bound; } float ConfidenceModule :: get_upper_bound() { return upper_bound; } void ConfidenceModule :: set_flag_upper_bound_exist(bool flag) { this->flag_upper_bound_exist = flag; } bool ConfidenceModule :: get_flag_upper_bound_exist() { return flag_upper_bound_exist; } void ConfidenceModule :: set_rates_of_change(float rates) { this->rates_of_change = rates; } float ConfidenceModule :: get_rates_of_change() { return rates_of_change; } void ConfidenceModule :: set_flag_rates_of_change_exist(bool flag) { this->flag_rates_of_change_exist = flag; } bool ConfidenceModule :: get_flag_rates_of_change_exist() { return flag_rates_of_change_exist; } \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/Evaluation.cpp b/Version_Max_07_05_2018_CMake/src/Evaluation.cpp index db0a16e..07f9318 100755 --- a/Version_Max_07_05_2018_CMake/src/Evaluation.cpp +++ b/Version_Max_07_05_2018_CMake/src/Evaluation.cpp @@ -1,163 +1,163 @@ #include "Evaluation.h" #include #include "boundary_check.h" Evaluation :: Evaluation() { } Evaluation :: Evaluation(Agent a) { agent = a; } void Evaluation :: set_agent(Agent a) { agent = a; } Agent Evaluation :: get_agent(){ return agent; } //TODO: Timeslot observation void Evaluation :: evaluate_scores_of_mounted_sensor() { /* for(unsigned int s_ix=0; s_ixget_number_of_scores(); if(sensor->get_flag_use_learned_data()) { if(is_it_lower_than_boundary(sensor, 0, LOWER_BOUNDARY)) { for(unsigned int score=1; scoreset_score(score); break; } else { sensor->set_score(score+1); } } } else if(is_it_higher_than_boundary(sensor, 0, UPPER_BOUNDARY)) { for(unsigned int score=1; scoreset_score(score); break; } else { sensor->set_score(score+1); } } } else { sensor->set_score(0); } } else { if(is_it_lower_than_hardcoded_boundary(sensor, 0, LOWER_BOUNDARY)) { for(unsigned int score=1; scoreset_score(score); break; } else { sensor->set_score(score+1); } } } else if(is_it_higher_than_hardcoded_boundary(sensor, 0, UPPER_BOUNDARY)) { for(unsigned int score=1; scoreset_score(score); break; } else { sensor->set_score(score+1); } } } else { sensor->set_score(0); } } printf("Sensor %s (mounted on Agent %s) has the value %f, which leads to the Sensor Score %u\n", sensor->get_name(), agent.get_name(), sensor->get_sensor_value(), sensor->get_score()); } } */ } //TODO: Timeslot observation int Evaluation :: evaluate_score_of_Agent() { /* float score = 0; if(agent.get_score_calculation_way() == ARITHMETIC_MEAN) { for(unsigned int s_ix=0; s_ixget_score(); } } for(unsigned int sa_ix=0; sa_ixget_score()); score += agent.get_mounted_subagent(sa_ix)->get_score(); } } printf(" < score: %f\n", score); score = score / (agent.get_number_of_active_mounted_sensors() + agent.get_number_of_active_mounted_subagents()); } - /* + else if(agent->get_score_calculation_way() == GEOMETRIC_MEAN) { for(unsigned int sensor=0; sensorget_sensor_state(sensor)) { score *= (agent->get_sensor_scores(sensor)+1); //TODO: is das +1 wirklich ok? number_of_active_sensors++; } } score = pow(score, 1/number_of_active_sensors) - 1; //und hier das -1...? } else if(agent->get_score_calculation_way() == HARMONIC_MEAN) { for(unsigned int sensor=0; sensorget_sensor_state(sensor)) { score *= (1 / (agent->get_sensor_scores(sensor)+1)); //TODO: is das +1 wirklich ok? number_of_active_sensors++; } } score = (number_of_active_sensors / score) - 1; //und hier das -1...? } else if(agent->get_score_calculation_way() == WEIGHTED_ARITHMETIC_MEAN) { for(unsigned int sensor=0; sensorget_sensor_state(sensor) && agent->get_sensor_priority(sensor) > 0.0) { score += ((agent->get_sensor_scores(sensor) + 1) * agent->get_sensor_priority(sensor)); //TODO: is das +1 wirklich ok? number_of_active_sensors++; } } score = (score / number_of_active_sensors) - 1; //und hier das -1...? } else if(agent->get_score_calculation_way() == WEIGHTED_GEOMETRIC_MEAN) { } else if(agent->get_score_calculation_way() == WEIGHTED_HARMONIC_MEAN) { } agent->set_agent_score((int)(score+0.5)); if(agent->get_agent_score() > agent->get_number_of_agent_scores()) { agent->set_agent_score(agent->get_number_of_agent_scores()); } printf("Total score of this Agent is: %i\n\n", agent->get_agent_score()); */ //return (int)(score+0.5); return 1; //dummy zeile } diff --git a/Version_Max_07_05_2018_CMake/src/HistoryModule.cpp b/Version_Max_07_05_2018_CMake/src/HistoryModule.cpp index e73291b..9bfb7b0 100755 --- a/Version_Max_07_05_2018_CMake/src/HistoryModule.cpp +++ b/Version_Max_07_05_2018_CMake/src/HistoryModule.cpp @@ -1,442 +1,442 @@ #include "HistoryModule.h" #include "printError.h" #include #define MAX_HIST_LENGTH 1000 //using namespace std; void HistoryModule :: initHistoryModule() { if(MAX_HIST_LENGTH <= vHistory.max_size()) { historyLength = MAX_HIST_LENGTH; } else { historyLength = vHistory.max_size(); } delimitationMode = DELIMITATE_MODE_SRWF; } HistoryModule :: HistoryModule() { set_name(NO_NAME); initHistoryModule(); } -HistoryModule :: HistoryModule(char* name) { +HistoryModule ::HistoryModule(std::string name) { initHistoryModule(); set_name(name); } bool HistoryModule :: set_maxHistoryLength(unsigned int length) { if(length <= MAX_HIST_LENGTH && length <= vHistory.max_size()) { - this->historyLength = historyLength; + this->historyLength = length; return true; } return false; } unsigned int HistoryModule :: get_maxHistoryLength() { return historyLength; } bool HistoryModule :: set_delimitationMode(int delimitationMode) { if(delimitationMode > DELIMITATE_MODE_LBOUND && delimitationMode < DELIMITATE_MODE_UBOUND) { this->delimitationMode = delimitationMode; return true; } return false; } int HistoryModule :: get_delimitationMode() { return delimitationMode; } /* bool HistoryModule :: add_entry(float entryValue) { if(vHistory.size() <= historyLength) { HistoryEntry* historyEntry = new HistoryEntry(); if(historyEntry != NULL) { historyEntry->set_entryValue(entryValue); try { vHistory.push_back(historyEntry); return true; } catch(bad_alloc& error) { printError("bad_alloc caught: ", error.what()); } } else { printError("Couldn't create HistoryEntry!"); } } else { switch(delimitationMode) { case DELIMITATE_MODE_SRWF: printError("History is already full!"); break; default : printError("History is already full! DelimitationMode isn't set!"); break; } } return false; } */ unsigned int HistoryModule :: get_numberOfEntries() { return vHistory.size(); } /* void HistoryModule :: initialize_history(unsigned int history_length, unsigned int recording_frequency, unsigned int delimitation_mode, int* success_indicator) { history_occupied = 0; history_pointer = 0; clk_counter = 1; if(!set_history_length(history_length)) { *success_indicator = 1; } else if(!set_recording_frequency(recording_frequency)) { *success_indicator = 2; } else if(!set_delimitation_mode(delimitation_mode)) { *success_indicator = 3; } else { *success_indicator = 0; } } HistoryModule :: HistoryModule(unsigned int history_length, unsigned int recording_frequency, unsigned int delimitation_mode, int* success_indicator) { set_name(NO_NAME); initialize_history(history_length, recording_frequency, delimitation_mode, success_indicator); } HistoryModule :: HistoryModule(char* name, unsigned int history_length, unsigned int recording_frequency, unsigned int delimitation_mode, int* success_indicator) { set_name(name); initialize_history(history_length, recording_frequency, delimitation_mode, success_indicator); } bool HistoryModule :: set_history_length(unsigned int history_length) { if(history_length > 0 && history_length <= MAX_HIST_LENGTH) { this->history_length = history_length; return true; } this->history_length = 0; return false; } bool HistoryModule :: set_recording_frequency(unsigned int recording_frequency) { if(recording_frequency <= MAX_REC_FREQU) { this->recording_frequency = recording_frequency; return true; } this->recording_frequency = 0; return false; } bool HistoryModule :: set_delimitation_mode(unsigned int delimitation_mode) { if(delimitation_mode > DELIMITATE_MODE_LBOUND && delimitation_mode < DELIMITATE_MODE_UBOUND) { this->delimitation_mode = delimitation_mode; return true; } this->delimitation_mode = HIST_DELIMITATE_MODE_SRWF; return false; } void HistoryModule :: carry_on_history_pointer() { if(history_pointer >= history_length-1) { history_pointer = 0; } else { history_pointer++; } } //TODO: namen berarbeiten bool HistoryModule :: drop_data(float data) { if(clk_counter == recording_frequency) { clk_counter = 1; return rec_data(data); } else { clk_counter++; return true; } return false; } bool HistoryModule :: rec_data(float data) { if(history_occupied < history_length-1) { history[history_pointer] = data; carry_on_history_pointer(); history_occupied++; return true; } else { if(delimitation_mode == HIST_DELIMITATE_MODE_SRWF) { return false; } else if(delimitation_mode == HIST_DELIMITATE_MODE_FIFO) { history[history_pointer] = data; carry_on_history_pointer(); return true; } else if(delimitation_mode == HIST_DELIMITATE_MODE_LIFO) { //TODO: implement! } else { return false; } } return false; } bool HistoryModule :: get_latest_value(float* value) { if(history_occupied > 0) { if(history_pointer > 0) { *value = history[history_pointer-1]; } else { *value = history[history_length-1]; } return true; } return false; } bool HistoryModule :: smooth_history() { if(history_occupied > 1) { unsigned int calculation_point; //TODO: kann man anders verschachteln .. in ein if mit || oder && if(history_occupied < MAX_HIST_LENGTH-1) { calculation_point = 0; } else { if(history_pointer < MAX_HIST_LENGTH-1) { calculation_point = history_pointer; } else { calculation_point = 0; } } //printf("calculation_point = %u\n", calculation_point); for(unsigned int t_ix=0; t_ix<=history_occupied-1; t_ix++) { float value, divider; if(calculation_point == 0) { //printf("hier?\n"); if(history_occupied == MAX_HIST_LENGTH-1) { //printf("ja!\n"); value = history[MAX_HIST_LENGTH-1]; divider = 1; } else { value = 0; divider = 0; } value = value + 2*history[calculation_point]; divider = divider + 2; //printf("value = %f\ndivider = %f\n", value, divider); //printf("is er da drinnen?\n"); if(t_ix < history_occupied-1) { //printf("ja\n"); value = value + history[calculation_point+1]; divider = divider + 1; } } else if(calculation_point == MAX_HIST_LENGTH-1) { value = history[calculation_point-1] + 2*history[calculation_point]; divider = 3; if(t_ix < history_occupied-1) { value = value + history[0]; divider = divider + 1; } } else { value = history[calculation_point-1] + 2*history[calculation_point]; divider = 3; //printf("da hoffentlich auch nicht\n"); if(t_ix < history_occupied-1) { //printf("doch\n"); value = value + history[calculation_point+1]; divider = divider + 1; } } //printf("value = %f\ndivider = %f\ncalculation_point = %u\n", value, divider, calculation_point); history_smoothed[t_ix] = value/divider; //printf("history_smoothed[%u] = %f\n", t_ix, history_smoothed[t_ix]); if(calculation_point < MAX_HIST_LENGTH-1) { calculation_point++; } else { calculation_point = 0; } } return true; } return false; } //TODO: TO CHECK: small bug when overflow of history array ??? bool HistoryModule :: get_history_trend(float* trend, unsigned int time_unites, unsigned int time_base) { - /* + float trend_temp, divider; bool got_smoothed = smooth_history(); if(got_smoothed) { if(time_unites <= MAX_HIST_LENGTH) { //TODO: fall wenn andere time base if(this->time_base == time_base) { if(time_unites < history_occupied) { //XXX <= oder < ??? //printf("a\n"); trend_temp = history_smoothed[history_occupied-1] - history_smoothed[history_occupied-time_unites]; //xxx -1-time_unites oder nur -time_unites ??? divider = (float)time_unites; } else { //printf("b\nhistory_smoothed[history_occupied-1] = %f mit history_occupied = %u\nhistory_smoothed[0] = %f\n", history_smoothed[history_occupied-1], history_occupied, history_smoothed[0]); trend_temp = history_smoothed[history_occupied-1] - history_smoothed[0]; divider = (float)history_occupied; //printf("divider = %f\n", divider); } *trend = trend_temp/divider; //printf("trend = %f\n", *trend); } return true; } } */ /* return false; } bool HistoryModule :: get_history_trend_absolutely(float* trend, unsigned int time_unites, unsigned int time_base) { float trend_temp; bool got_trend = get_history_trend(&trend_temp, time_unites, time_base); if(got_trend) { if(trend_temp < 0) { trend_temp = trend_temp * -1; } *trend = trend_temp; return true; } return false; } unsigned int HistoryModule :: get_history_occupied() { return history_occupied; } //TODO: Fehlerbehandlung! float HistoryModule :: get_value_ago(unsigned int ago) { if(history_occupied >= ago) { if(history_pointer < ago) { return history[MAX_HIST_LENGTH-(ago-history_pointer)]; //TO CHECK .. auch ein -1 dazu?? } else { return history[history_pointer-ago]; } } else if (history_occupied > 0) { return history[0]; } else { printf("\n\n\n\n\n\n\nBOESE"); return 0; } } -/* + void History :: set_history(unsigned int point, float value) { if(point /* #define MAX_HIST_LENGTH 1000 #define MAX_REC_FREQU 4294967295 */ #define DELIMITATE_MODE_LBOUND 0 #define DELIMITATE_MODE_SRWF 1 //Stop Recording When Full #define DELIMITATE_MODE_FIFO 2 //First In First Out #define DELIMITATE_MODE_LIFO 3 //Last In First Out #define DELIMITATE_MODE_UBOUND 4 using namespace std; class HistoryModule : public Module { private: vector vHistory; unsigned int historyLength; int delimitationMode; void initHistoryModule(); public: HistoryModule(); - HistoryModule(char* name); + HistoryModule(std::string name); bool set_maxHistoryLength(unsigned int length); unsigned int get_maxHistoryLength(); bool set_delimitationMode(int delimitationMode); int get_delimitationMode(); //bool add_entry(); unsigned int get_numberOfEntries(); /* float history[MAX_HIST_LENGTH]; unsigned int history_length; unsigned int recording_frequency; unsigned int delimitation_mode; unsigned int history_occupied; unsigned int history_pointer; unsigned int clk_counter; //unsigned int time_base; float history_smoothed[MAX_HIST_LENGTH]; //private functions void initialize_history(unsigned int history_length, unsigned int recording_frequency, unsigned int delimitation_mode, int* success_indicator); void carry_on_history_pointer(); bool smooth_history(); public: HistoryModule(unsigned int history_length, unsigned int recording_frequency, unsigned int delimitation_mode, int* success_indicator); HistoryModule(char* name, unsigned int history_length, unsigned int recording_frequency, unsigned int delimitation_mode, int* success_indicator); bool set_history_length(unsigned int history_length); bool set_recording_frequency(unsigned int recording_frequency); bool set_delimitation_mode(unsigned int delimitation_mode); bool drop_data(float data); bool rec_data(float data); bool get_latest_value(float* value); bool get_history_trend(float* trend, unsigned int time_unites, unsigned int time_base); bool get_history_trend_absolutely(float* trend, unsigned int time_unites, unsigned int time_base); unsigned int get_history_occupied(); float get_value_ago(unsigned int ago); */ }; #endif \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/LinearFunctionBlock.cpp b/Version_Max_07_05_2018_CMake/src/LinearFunctionBlock.cpp index c5fe44f..231eaf5 100755 --- a/Version_Max_07_05_2018_CMake/src/LinearFunctionBlock.cpp +++ b/Version_Max_07_05_2018_CMake/src/LinearFunctionBlock.cpp @@ -1,109 +1,132 @@ #include "LinearFunctionBlock.h" #include #define PRINT LinearFunctionBlock::LinearFunctionBlock() { #ifdef PRINT printf(" > Linear Function Block created\n"); #endif // PRINT } -LinearFunctionBlock::LinearFunctionBlock(char* name) : Module(name) { +LinearFunctionBlock::LinearFunctionBlock(std::string name) : Module(name) { #ifdef PRINT - printf(" > %s (id:%u) created\n", name, id); + printf(" > %s (id:%u) created\n", name.c_str(), id); #endif // PRINT } LinearFunctionBlock::~LinearFunctionBlock() { LinearFunction* cur_Linear_Function; unsigned int index_cur_Linear_Function; unsigned int size_vec_Linear_Functions = vLinearFunctions.size(); for(index_cur_Linear_Function = 0; index_cur_Linear_Function < size_vec_Linear_Functions; index_cur_Linear_Function++){ cur_Linear_Function = vLinearFunctions[index_cur_Linear_Function]; delete cur_Linear_Function; } vLinearFunctions.clear(); } //NOTE: for this time being, linear functions have to be filled beginning from lowest x value bool LinearFunctionBlock::addLinearFunction(LinearFunction *linearFunction) { if (vLinearFunctions.empty()) { //printf("empty\n"); if (!(linearFunction->getDomain()->lowerBoundaryExist())) { vLinearFunctions.push_back(linearFunction); #ifdef PRINT printf(" - added function\n"); #endif // PRINT return true; } } else { //printf("nicht empty\n"); if (vLinearFunctions.back()->getDomain()->upperBoundaryExist() && linearFunction->getDomain()->lowerBoundaryExist()) { //printf("last function ub = %f, new function lb = %f\n", lLinearFunctions.back()->getDomain()->getUpperBoundary(), linearFunction->getDomain()->getLowerBoundary()); if (vLinearFunctions.back()->getDomain()->getUpperBoundary() == linearFunction->getDomain()->getLowerBoundary()) { vLinearFunctions.push_back(linearFunction); #ifdef PRINT printf(" - added function\n"); #endif // PRINT return true; } } } #ifdef PRINT printf(" - couldn't add function\n"); #endif // PRINT return false; } //NOTE: Specific Function for CAH Project (DATE18) void LinearFunctionBlock::changeFunctionBlockIncr(float newBoundary) { vLinearFunctions[1]->setDomain(true, (float)0, true, newBoundary); vLinearFunctions[1]->setKandD((float)0, (float)0, newBoundary, (float)1); vLinearFunctions[2]->setDomain(true, newBoundary, false); } void LinearFunctionBlock::changeFunctionBlockDecr(float newBoundary) { vLinearFunctions[1]->setDomain(true, (float)0, true, newBoundary); vLinearFunctions[1]->setKandD((float)0, (float)1, newBoundary, (float)0); vLinearFunctions[2]->setDomain(true, newBoundary, false); } //TODO: jump discontinuity -> user must have the probability to set the value there float LinearFunctionBlock::getY(float x) { for (auto &linearFunction : vLinearFunctions) { if (linearFunction->getDomain()->lowerBoundaryExist() && linearFunction->getDomain()->upperBoundaryExist()) { if (x >= linearFunction->getDomain()->getLowerBoundary() && x <= linearFunction->getDomain()->getUpperBoundary()) { return linearFunction->getY(x); } } else if (linearFunction->getDomain()->lowerBoundaryExist()) { if (x >= linearFunction->getDomain()->getLowerBoundary()) { return linearFunction->getY(x); } } else if (linearFunction->getDomain()->upperBoundaryExist()) { if (x <= linearFunction->getDomain()->getUpperBoundary()) { return linearFunction->getY(x); } } else { return linearFunction->getY(x); } } //the next two lines should be deleted, but if you call the function getY you have to check for NaN! printf("DEFAULT!!!!!!!!!!!\n"); getchar(); - return std::numeric_limits::quiet_NaN(); + return std::numeric_limits::quiet_NaN(); +} + +void LinearFunctionBlock ::printFunctionBlock(std::string name) { + printf("Name: %s", name.c_str()); + + for (auto &lf : vLinearFunctions) { + + float lowerBoundary; + float upperBoundary; + + if (lf->getDomain()->getLowerBoundary(&lowerBoundary)) + printf("(x,y) %f, %f - ", lowerBoundary, lf->getY(lowerBoundary)); + else + printf("oo - "); + + if (lf->getDomain()->getUpperBoundary(&upperBoundary)) + printf("%f, %f", upperBoundary, lf->getY(upperBoundary)); + else + printf("oo"); + + printf("\n"); + + } } vector& LinearFunctionBlock::get_all_LinearFunctions() { return vLinearFunctions; } diff --git a/Version_Max_07_05_2018_CMake/src/LinearFunctionBlock.h b/Version_Max_07_05_2018_CMake/src/LinearFunctionBlock.h index d85d07a..3fceb15 100755 --- a/Version_Max_07_05_2018_CMake/src/LinearFunctionBlock.h +++ b/Version_Max_07_05_2018_CMake/src/LinearFunctionBlock.h @@ -1,35 +1,37 @@ #ifndef LINEARFUNCTIONBLOCK_HEADERFILE #define LINEARFUNCTIONBLOCK_HEADERFILE #include #include #include "LinearFunction.h" #include "Module.h" #include "stdio.h" using namespace std; class LinearFunctionBlock : public Module{ private: //CHECK: list, vector or other container? vector vLinearFunctions; public: LinearFunctionBlock(); - LinearFunctionBlock(char* name); + LinearFunctionBlock(std::string name); ~LinearFunctionBlock(); bool addLinearFunction(LinearFunction *linearFunction); //NOTE: Specific Function for CAH Project (DATE18) void changeFunctionBlockIncr(float newBoundary); void changeFunctionBlockDecr(float newBoundary); vector& get_all_LinearFunctions(); float getY(float x); + + void printFunctionBlock(std::string name); }; #endif diff --git a/Version_Max_07_05_2018_CMake/src/MasterAgentSlotOfAgent.h b/Version_Max_07_05_2018_CMake/src/MasterAgentSlotOfAgent.h index dd94ad1..0a196b0 100755 --- a/Version_Max_07_05_2018_CMake/src/MasterAgentSlotOfAgent.h +++ b/Version_Max_07_05_2018_CMake/src/MasterAgentSlotOfAgent.h @@ -1,17 +1,17 @@ #ifndef MASTERAGENTSLOTOFAGENT_HEADERFILE #define MASTERAGENTSLOTOFAGENT_HEADERFILE #include "SlotOfAgent.h" class MasterAgentSlotOfAgent : public SlotOfAgent { private: - MasterAgentSlotOfAgent* masterAgentSlotOfAgent; + //MasterAgentSlotOfAgent* masterAgentSlotOfAgent; public: MasterAgentSlotOfAgent(); }; #endif \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/Module.cpp b/Version_Max_07_05_2018_CMake/src/Module.cpp index 51c7b1d..eb2e29a 100755 --- a/Version_Max_07_05_2018_CMake/src/Module.cpp +++ b/Version_Max_07_05_2018_CMake/src/Module.cpp @@ -1,19 +1,20 @@ #include "Module.h" Module :: Module() { set_name(NO_NAME); } -Module :: Module(char* name) { +Module ::Module(std::string name) { set_name(name); } -void Module :: set_name(char* name) { - strncpy (this->name, name, MAX_LENGTH_NAME); +void Module :: set_name(std::string name) { + this->name = name; + //strncpy (this->name, name, MAX_LENGTH_NAME); } -char* Module :: get_name() { +std::string Module :: get_name() { return this->name; } diff --git a/Version_Max_07_05_2018_CMake/src/Module.h b/Version_Max_07_05_2018_CMake/src/Module.h index 0fc0f74..cbb0598 100755 --- a/Version_Max_07_05_2018_CMake/src/Module.h +++ b/Version_Max_07_05_2018_CMake/src/Module.h @@ -1,20 +1,22 @@ #ifndef MODULE_HEADERFILE #define MODULE_HEADERFILE -#include +#include #include "Unit.h" class Module : public Unit { protected: - char name[MAX_LENGTH_NAME]; + std::string name; + //[MAX_LENGTH_NAME]; public: Module(); - Module(char* name); + Module(std::string name); + + void set_name(std::string name); + std::string get_name(); - void set_name(char* name); - char* get_name(); }; #endif diff --git a/Version_Max_07_05_2018_CMake/src/Sensor.cpp b/Version_Max_07_05_2018_CMake/src/Sensor.cpp index 06776da..97c2ba5 100755 --- a/Version_Max_07_05_2018_CMake/src/Sensor.cpp +++ b/Version_Max_07_05_2018_CMake/src/Sensor.cpp @@ -1,184 +1,184 @@ #include "Sensor.h" #include //unsigned int Sensor :: number_of_sensors = 0; void Sensor :: initialize_sensor() { this->flag_masteragent_is_mounted = UNMOUNTED; this->flag_masteragent_outputport_is_active = INACTIVE; this->flag_sensor_value_is_valid = INVALID; this->flag_sensor_value_has_changed = NO; this->flag_send_value_only_when_changed = NO; workingCycleCounter = 1; } Sensor :: Sensor() { set_name(NO_NAME); initialize_sensor(); } -Sensor :: Sensor(char* name) { +Sensor :: Sensor(std::string name) { set_name(name); initialize_sensor(); } // ----- Runtime Functions ----- void Sensor :: set_sensorValue(float sensor_value) { if (sensor_value != sensor_value) { //If NaN if (flag_sensor_value_is_valid == true) { // don't do anything .. just keep old value } else { this->sensor_value = 0; //xxx - don't know if 0 is the best default value.. but in the beginning of a dataset, it most likely won't affact anything } } else { if (flag_sensor_value_is_valid == true) { if (this->sensor_value != sensor_value) { flag_sensor_value_has_changed = YES; } } flag_sensor_value_is_valid = VALID; this->sensor_value = sensor_value; } //printf("Sensor %s updated with: %f\n", name, sensor_value); } float Sensor :: get_sensorValue() { return sensor_value; } void Sensor :: trigger() { if (workingCycleCounter == 1) { //TODO: difference int and float if(this->flag_sensor_value_is_valid && this->flag_masteragent_is_mounted && this->flag_masteragent_outputport_is_active){ if(flag_send_value_only_when_changed) { if(flag_sensor_value_has_changed) { mounted_masteragent_outputport->send_MsgUp(sensor_value); flag_sensor_value_has_changed = NO; } } else { mounted_masteragent_outputport->send_MsgUp(sensor_value); flag_sensor_value_has_changed = NO; } } } if (workingCycleCounter < get_workingCycle()) workingCycleCounter++; else workingCycleCounter = 1; } // ----- Setup Functions ----- bool Sensor :: mount_agent(Channel* outputport) { if(outputport != NULL) { this->mounted_masteragent_outputport = outputport; this->flag_masteragent_is_mounted = MOUNTED; this->flag_masteragent_outputport_is_active = ACTIVE; return true; } return false; } void Sensor :: set_flag_send_value_only_when_changed(bool flag_send_value_only_when_changed) { this->flag_send_value_only_when_changed = flag_send_value_only_when_changed; } bool Sensor :: get_flag_send_value_only_when_changed() { return this->flag_send_value_only_when_changed; } // ----- set/get ----- void Sensor :: set_flag_sensor_value_is_valid(bool flag_sensor_value_is_valid) { this->flag_sensor_value_is_valid = flag_sensor_value_is_valid; } bool Sensor :: get_flag_sensor_value_is_valid() { return this->flag_sensor_value_is_valid; } void Sensor :: set_flag_sensor_value_has_changed(bool flag_sensor_value_has_changed) { this->flag_sensor_value_has_changed = flag_sensor_value_has_changed; } bool Sensor :: get_flag_sensor_value_has_changed() { return this->flag_sensor_value_has_changed; } /* void Sensor :: set_sensor_id(unsigned int id) { sensor_id = id; } unsigned int Sensor :: get_sensor_id() { return sensor_id; }*/ void Sensor :: set_active_state_flag(bool flag) { active_state_flag = flag; } bool Sensor :: get_active_state_flag() { return active_state_flag; } /* void Sensor :: set_number_of_scores (unsigned int number) { number_of_scores = number; } unsigned int Sensor :: get_number_of_scores() { return number_of_scores; } */ float Sensor :: get_hardcoded_threshold(unsigned int score, unsigned int boundary) { return hardcoded_thresholds[score][boundary]; } void Sensor :: set_hardcoded_threshold(unsigned int score, unsigned int boundary, float value) { hardcoded_thresholds[score][boundary] = value; } float Sensor :: get_learned_threshold(unsigned int score, unsigned int boundary) { return learned_thresholds[score][boundary]; } void Sensor :: set_learned_threshold(unsigned int score, unsigned int boundary, float value) { learned_thresholds[score][boundary] = value; } void Sensor :: set_flag_learned_boundary_exist(unsigned int score, unsigned int boundary, bool flag) { flag_learned_boundary_exist[score][boundary] = flag; } bool Sensor :: get_flag_learned_boundary_exist(unsigned int score, unsigned int boundary) { return flag_learned_boundary_exist[score][boundary]; } void Sensor :: set_flag_use_learned_data(bool flag) { flag_use_learned_data = flag; } bool Sensor :: get_flag_use_learned_data() { return flag_use_learned_data; } diff --git a/Version_Max_07_05_2018_CMake/src/Sensor.h b/Version_Max_07_05_2018_CMake/src/Sensor.h index 5619d3d..f525ec5 100755 --- a/Version_Max_07_05_2018_CMake/src/Sensor.h +++ b/Version_Max_07_05_2018_CMake/src/Sensor.h @@ -1,119 +1,119 @@ #ifndef SENSOR_HEADERFILE #define SENSOR_HEADERFILE #include "project_settings.h" #include "Node.h" #include "Channel.h" #define MAX_NUM_OF_SCORES 10 #define LOWER_BOUNDARY 0 #define UPPER_BOUNDARY 1 #define LEARNED_BOUNDARY_DOES_EXIST true #define LEARNED_BOUNDARY_DOESNT_EXIST false #define USE_LEARNED_DATA true #define DONT_USE_LEARNED_DATA false #define VALID true #define INVALID false class Sensor : public Node { private: // ----- Runtime ----- float sensor_value; bool flag_sensor_value_is_valid; bool flag_sensor_value_has_changed; // ----- Setup Master ----- bool flag_masteragent_is_mounted; Channel* mounted_masteragent_outputport; bool flag_masteragent_outputport_is_active; //unntig? // ----- Setup Behavior ----- bool flag_send_value_only_when_changed; unsigned int workingCycleCounter; //noch nicht berarbeitet bool active_state_flag; float hardcoded_thresholds[MAX_NUM_OF_SCORES][2]; float learned_thresholds[MAX_NUM_OF_SCORES][2]; bool flag_learned_boundary_exist[MAX_NUM_OF_SCORES][2]; bool flag_use_learned_data; void initialize_sensor(); public: Sensor(); - Sensor(char* name); + Sensor(std::string name); // ----- Runtime Functions ----- void set_sensorValue(float sensor_value); float get_sensorValue(); void trigger(); // ----- Setup ----- bool mount_agent(Channel* outputport); void set_flag_send_value_only_when_changed(bool flag_send_value_only_when_changed); bool get_flag_send_value_only_when_changed(); /* void set_sensor_id(unsigned int id); unsigned int get_sensor_id(); */ // ----- set/get ----- void set_flag_sensor_value_is_valid(bool flag_sensor_value_is_valid); bool get_flag_sensor_value_is_valid(); void set_flag_sensor_value_has_changed(bool flag_sensor_value_has_changed); bool get_flag_sensor_value_has_changed(); void set_active_state_flag(bool flag); bool get_active_state_flag(); float get_hardcoded_threshold(unsigned int score, unsigned int boundary); void set_hardcoded_threshold(unsigned int score, unsigned int boundary, float value); float get_learned_threshold(unsigned int score, unsigned int boundary); void set_learned_threshold(unsigned int score, unsigned int boundary, float value); void set_flag_learned_boundary_exist(unsigned int score, unsigned int boundary, bool flag); bool get_flag_learned_boundary_exist(unsigned int score, unsigned int boundary); void set_flag_use_learned_data(bool flag); bool get_flag_use_learned_data(); }; #endif \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/SlaveAgentSlotOfAgent.cpp b/Version_Max_07_05_2018_CMake/src/SlaveAgentSlotOfAgent.cpp index 12ae84f..82fa5d2 100755 --- a/Version_Max_07_05_2018_CMake/src/SlaveAgentSlotOfAgent.cpp +++ b/Version_Max_07_05_2018_CMake/src/SlaveAgentSlotOfAgent.cpp @@ -1,225 +1,225 @@ #include "SlaveAgentSlotOfAgent.h" #include "stdio.h" #include "printError.h" #include "relationChecker.h" SlaveAgentSlotOfAgent :: SlaveAgentSlotOfAgent() { flagSlaveAgentValueIsSet = false; /* flagSlaveAgentValueHasChanged = false; flagSlaveAgentValueChangeIsSet = false; - /* + activeState = NULL; backupState = NULL; */ } void SlaveAgentSlotOfAgent :: setSlaveAgentValue(float slaveAgentValue) { this->slaveAgentValue = slaveAgentValue; flagSlaveAgentValueIsSet = true; /* if(flagSlaveAgentValueIsSet == false) { this->slaveAgentValue = slaveAgentValue; flagSlaveAgentValueIsSet = true; flagSlaveAgentValueHasChanged = true; } else { if(this->slaveAgentValue != slaveAgentValue) { flagSlaveAgentValueHasChanged = true; flagSlaveAgentValueChangeIsSet = true; slaveAgentValueChange = slaveAgentValue - this->slaveAgentValue; this->slaveAgentValue = slaveAgentValue; } else { flagSlaveAgentValueHasChanged = false; flagSlaveAgentValueChangeIsSet = true; slaveAgentValueChange = 0; } } */ //printf("slaveAgentSlot updated with: %f\n", this->slaveAgentValue); } bool SlaveAgentSlotOfAgent :: get_slaveAgentValue(float* slaveAgentValue) { if(flagSlaveAgentValueIsSet == true) { *slaveAgentValue = this->slaveAgentValue; return true; } return false; } bool SlaveAgentSlotOfAgent :: get_flagSlaveAgentValueIsSet() { return flagSlaveAgentValueIsSet; } //TODO: move these functions into -> HistoryHandler bool SlaveAgentSlotOfAgent::saveValueInHistory() { if (flagSlaveAgentValueIsSet) { try { //printf("history saving - value: %f\n", slaveAgentValue); lSlaveAgentHistory.push_back(slaveAgentValue); return true; } catch (bad_alloc& error) { printError("bad_alloc caught: ", error.what()); } } return false; } unsigned int SlaveAgentSlotOfAgent::getHistoryLength() { return lSlaveAgentHistory.size(); } bool SlaveAgentSlotOfAgent::deleteOldestHistoryEntry() { if (!lSlaveAgentHistory.empty()) { lSlaveAgentHistory.pop_front(); return true; } return false; } unsigned int SlaveAgentSlotOfAgent::getNumberOfRelativesToActualValue(float threshold) { unsigned int numberOfRelativesToActualValue = 0; for (auto &entry : lSlaveAgentHistory) { if (valueIsRelatedToReferenceValue(slaveAgentValue, entry, threshold)) { numberOfRelativesToActualValue++; } } return numberOfRelativesToActualValue; } //DATE18 list SlaveAgentSlotOfAgent::getHistory() { return lSlaveAgentHistory; } void SlaveAgentSlotOfAgent::printHistory() { printf("History: "); for (auto &entry : lSlaveAgentHistory) { printf("%f, ", entry); } printf("\n"); } SlaveAgentSlotOfAgent :: ~SlaveAgentSlotOfAgent() { - int i = 0; + //int i = 0; } /* bool SlaveAgentSlotOfAgent :: get_flagSlaveAgentValueHasChanged() { return flagSlaveAgentValueHasChanged; } bool SlaveAgentSlotOfAgent :: get_slaveAgentValueChangingRate(float* slaveAgentValueChangingRate) { if(flagSlaveAgentValueChangeIsSet) { *slaveAgentValueChangingRate = this->slaveAgentValueChange; return true; } return false; } -/* + bool SlaveAgentSlotOfAgent :: addStateToStatesVector(State* state) { if (state != NULL) { try { vStates.push_back(state); return true; } catch (bad_alloc& error) { printError("bad_alloc caught: ", error.what()); delete state; } } return false; } vector* SlaveAgentSlotOfAgent :: getStatesVector() { return &vStates; } bool SlaveAgentSlotOfAgent :: createNewStateAndMakeItActive() { State* state = new State(); if (addStateToStatesVector(state)) { backupState = activeState; activeState = state; return true; } return false; } bool SlaveAgentSlotOfAgent :: injectValueInActiveState() { if (activeState == NULL) { if (createNewStateAndMakeItActive()) { return activeState->injectValue(slaveAgentValue); } } return activeState->injectValue(slaveAgentValue); } int SlaveAgentSlotOfAgent :: getIndexOfRelatedState(unsigned int startIndex, float thresholdToAverage) { if (startIndex >= vStates.size()) return -2; int index = 0; for (vector::iterator state = vStates.begin() + startIndex; state < vStates.end(); state++, index++) { if ((*state)->valueIsRelated(slaveAgentValue, thresholdToAverage)) { return index; } } return -1; } bool SlaveAgentSlotOfAgent :: relatedToActiveState(float thresholdToAverage) { printf("a\n"); if (activeState == NULL) { printf("b\n"); createNewStateAndMakeItActive(); return true; } return activeState->valueIsRelated(slaveAgentValue, thresholdToAverage); } bool SlaveAgentSlotOfAgent :: valueIsRelated(unsigned int index, float thresholdToAverage) { return vStates[index]->valueIsRelated(slaveAgentValue, thresholdToAverage); } State* SlaveAgentSlotOfAgent :: getActiveState() { return activeState; } void SlaveAgentSlotOfAgent :: deleteActiveState() { //if(vStates.empty() == false) vStates.back()->deleteState(); vStates.pop_back(); if (backupState != NULL) { activeState = backupState; backupState = NULL; } } bool SlaveAgentSlotOfAgent :: setActiveState(unsigned int index) { if (vStates.size() > index) { activeState = vStates.at(index); return true; } return false; } unsigned int SlaveAgentSlotOfAgent::getNumberOfStates() { if (!vStates.empty()) printf("%u - ", activeState->getNumberOfInjections()); return vStates.size(); } */ diff --git a/Version_Max_07_05_2018_CMake/src/SlaveAgentSlotOfAgent.h b/Version_Max_07_05_2018_CMake/src/SlaveAgentSlotOfAgent.h index dfc9269..b772f34 100755 --- a/Version_Max_07_05_2018_CMake/src/SlaveAgentSlotOfAgent.h +++ b/Version_Max_07_05_2018_CMake/src/SlaveAgentSlotOfAgent.h @@ -1,83 +1,42 @@ #ifndef SLAVEAGENTSLOTOFAGENT_HEADERFILE #define SLAVEAGENTSLOTOFAGENT_HEADERFILE #include "SlotOfAgent.h" //#include "State.h" class SlaveAgentSlotOfAgent : public SlotOfAgent { private: //TODO: set- and get function for maxNumOf_mountedSensors; float slaveAgentValue; list lSlaveAgentHistory; bool flagSlaveAgentValueIsSet; - /* - //XXX - next 3 variables needed? - bool flagSlaveAgentValueHasChanged; - bool flagSlaveAgentValueChangeIsSet; - float slaveAgentValueChange; - */ - - - - /* - vector vStates; - State* activeState; - State* backupState; - - bool - ateToStatesVector(State* state); - */ public: SlaveAgentSlotOfAgent(); void setSlaveAgentValue(float slaveAgentValue); bool get_slaveAgentValue(float* slaveAgentValue); bool get_flagSlaveAgentValueIsSet(); //TODO: move these functions into -> HistoryHandler bool saveValueInHistory(); unsigned int getHistoryLength(); bool deleteOldestHistoryEntry(); unsigned int getNumberOfRelativesToActualValue(float threshold); //DATE18 list getHistory(); void printHistory(); ~SlaveAgentSlotOfAgent(); - - /* - bool get_flagSlaveAgentValueHasChanged(); - - bool get_slaveAgentValueChangingRate(float* slaveAgentValueChangingRate); - - /* - vector* getStatesVector(); - bool createNewStateAndMakeItActive(); - bool injectValueInActiveState(); - int getIndexOfRelatedState(unsigned int startIndex, float thresholdToAverage); - - bool relatedToActiveState(float thresholdToAverage); - bool valueIsRelated(unsigned int index, float thresholdToAverage); - - State* getActiveState(); - void deleteActiveState(); - bool setActiveState(unsigned int index); - unsigned int getNumberOfStates(); - */ - /* - vector* getStatesVector(); - State* getActiveState(); - */ }; #endif diff --git a/Version_Max_07_05_2018_CMake/src/StateHandler.cpp b/Version_Max_07_05_2018_CMake/src/StateHandler.cpp index 61793f0..89a4c7e 100755 --- a/Version_Max_07_05_2018_CMake/src/StateHandler.cpp +++ b/Version_Max_07_05_2018_CMake/src/StateHandler.cpp @@ -1,1832 +1,1848 @@ #include "StateHandler.h" #include "config.h" #include #include "printError.h" #include "rlutil.h" #include "relationChecker.h" #include "minmaxzeug.h" #include "file_util.h" #include #include //CHANGE ALSO BOTH FUZZY FUNCTION!!! // is used for the history length of the number of values which will be compared //to the current value #define MAX_STATE_HISTORY_LENGTH 10 //10 #define STOP_WHEN_BROKEN -//#define STOP_AFTER_BROKEN -//#define STOP_WHEN_DRIFT -//#define STOP_WHEN_STATE_VALID +#define STOP_AFTER_BROKEN +#define STOP_WHEN_DRIFT +#define STOP_WHEN_STATE_VALID #define PRINT //TODO: also change also hardcoded value in "SlaveAgentHandlerOfAgent.cpp" #define SLIDINGWINDOWSIZE 3 //3 //10 #define STABLENUMBER 2 //2 //8 #define STABLETHRESHOLD (float)0.04 //0.4 //0.03 #define RELATEDTHRESHOLD (float)0.08 //0.08 #define INJECTIONPARTITIONING 5 #define CMPDISTANCE 3 #define THDRIFT (float)0.08 //0.8 #define MINNUMTOBEVALIDSTATE 11 //11 //8 //10 //three different status are for the system possible #define STATUS_BROKEN 1 #define STATUS_DRIFT 2 #define STATUS_OKAY 3 using namespace rlutil; - +//TODO berladen mit Parameter CSV-Writer Name. :-) Bitte, nur fr dich Maxi. void StateHandler::initStateHandler() { csv_writer = NULL; flagVariablesWereStable = false; slidingWindowBufferSize = SLIDINGWINDOWSIZE; minNumOfRelatedValuesToBeStable = STABLENUMBER; thresholdToBeStable = STABLETHRESHOLD; thresholdToBeRelated = RELATEDTHRESHOLD; discreteAveragePartitionSize = INJECTIONPARTITIONING; compareDistanceDiscreteAveragePartition = CMPDISTANCE; thresholdNotDrift = THDRIFT; minNumToBeValidState = MINNUMTOBEVALIDSTATE; activeState = NULL; maxStateHistoryLength = MAX_STATE_HISTORY_LENGTH; time_t rawtime; - struct tm * timeinfo; - char output_file_name[200]; + + struct tm timeinfo; + //char output_file_name[200]; char datetime[80]; const std::string output_directory_name = "../data/out/"; // "./output_data_csv/Opel/2018-08-09/"; there is no impact if we change it! std::string output_file_name_str; time(&rawtime); - timeinfo = localtime(&rawtime); + //timeinfo = localtime(&rawtime); + localtime_s(&timeinfo, &rawtime); - strftime(datetime, sizeof(datetime), "%Y-%m-%d_%I-%M-%S", timeinfo); + strftime(datetime, sizeof(datetime), "%Y-%m-%d_%I-%M-%S", &timeinfo); #ifndef INPUT_FILE_NAME output_file_name_str = output_directory_name + "output" + datetime + ".csv"; #else output_file_name_str = output_directory_name + INPUT_FILE_NAME + datetime + ".csv"; #endif //INPUT_FILE_NAME cout << output_file_name_str << endl; //XXX - only for now: //Ali printf("\n csv_Writer is not NULL, but it is not initialized!! \n"); + /* if (csv_writer == NULL) { csv_writer = new CSV_Writer("CSV Writer", (char*)output_file_name_str.c_str()); } - + */ //DATE18 confidenceStableInput = 0; confidenceStableOutput = 0; confidenceStable = 0; confStableAdjustableThreshold = 0.5; confidenceUnstableInput = 0; confidenceUnstableOutput = 0; confidenceUnstable = 0; confidenceUnstableAdjustableThreshold = 0.5; confidenceSameStateInput = 0; confSameStateInputAdjustableThreshold = 0.5; confidenceSameStateOutput = 0; confSameStateOutputAdjustableThreshold = 0.5; confidenceValidState = 0; confValidStateAdjustableThreshold = 0.5; brokenCounter = 0; confidenceBroken = 0; confidenceBrokenAdjustableThreshold = 0.5; driftCounter = 0; confidenceDrift = 0; confidenceDriftAdjustableThreshold = 0.5; } StateHandler::StateHandler() { set_name(NO_NAME); initStateHandler(); } -StateHandler::StateHandler(char* name) { +StateHandler::StateHandler(std::string name) { set_name(name); initStateHandler(); } +StateHandler::StateHandler(std::string name, std::string csvWriterPath) { + set_name(name); + initStateHandler(); + csv_writer = new CSV_Writer("CSV Writer", csvWriterPath); +} + bool StateHandler::setDiscreteAveragePartitionSize(unsigned int discreteAveragePartitionSize) { if (discreteAveragePartitionSize > 0) { this->discreteAveragePartitionSize = discreteAveragePartitionSize; return true; } return false; } unsigned int StateHandler::getDiscreteAveragePartitionSize() { return discreteAveragePartitionSize; } bool StateHandler::addVariable(vector* vVariables, SlaveAgentSlotOfAgent* slot) { if (vVariables != NULL && slot != NULL) { if (find((*vVariables).begin(), (*vVariables).end(), slot) == (*vVariables).end()) { try { (*vVariables).push_back(slot); return true; } catch (bad_alloc& error) { printError("bad_alloc caught: ", error.what()); } } } return false; } bool StateHandler::addInputVariable(SlaveAgentSlotOfAgent* slot) { return addVariable(&vInputVariables, slot); } bool StateHandler::addOutputVariable(SlaveAgentSlotOfAgent* slot) { return addVariable(&vOutputVariables, slot); } bool StateHandler::delete_all_OuputVariables() { SlaveAgentSlotOfAgent* cur_sl_ag_sl_ag; unsigned int index_v_OutVar; unsigned int size_v_OutVar = vOutputVariables.size(); for(index_v_OutVar = 0; index_v_OutVar < size_v_OutVar; index_v_OutVar++) { cur_sl_ag_sl_ag = vOutputVariables[index_v_OutVar]; delete cur_sl_ag_sl_ag; } vOutputVariables.clear(); return true; //added by Ali, it is an error in VS. } bool StateHandler::delete_all_InputVariables() { SlaveAgentSlotOfAgent* cur_sl_ag_sl_ag; unsigned int index_v_InpVar; unsigned int size_v_InpVar = vInputVariables.size(); for(index_v_InpVar = 0; index_v_InpVar < size_v_InpVar; index_v_InpVar++) { cur_sl_ag_sl_ag = vInputVariables[index_v_InpVar]; delete cur_sl_ag_sl_ag; } vInputVariables.clear(); return true; //added by Ali, it is an error in VS. } bool StateHandler::delete_allStates() { State* cur_state; unsigned int index_v_State; unsigned int size_v_State = vStates.size(); for(index_v_State = 0; index_v_State < size_v_State; index_v_State++) { cur_state = vStates[index_v_State]; delete cur_state; } vStates.clear(); return true; //added by Ali, it is an error in VS. } bool StateHandler::setSlidingWindowBufferSize(unsigned int slidingWindowBufferSize) { if (slidingWindowBufferSize >= minNumOfRelatedValuesToBeStable) { this->slidingWindowBufferSize = slidingWindowBufferSize; return true; } return false; } bool StateHandler::setMinNumOfRelatedValuesToBeStable(unsigned int minNumOfRelatedValuesToBeStable) { if (minNumOfRelatedValuesToBeStable <= slidingWindowBufferSize) { this->minNumOfRelatedValuesToBeStable = minNumOfRelatedValuesToBeStable; return true; } return false; } bool StateHandler::setThresholdToBeStable(float thresholdToBeStable) { if (thresholdToBeStable >= 0 && thresholdToBeStable <= 1) { this->thresholdToBeStable = thresholdToBeStable; return true; } return false; } bool StateHandler::setThresholdToBeRelated(float thresholdToBeRelated) { if (thresholdToBeRelated >= 0 && thresholdToBeRelated <= 1) { this->thresholdToBeRelated = thresholdToBeRelated; return true; } return false; } bool StateHandler::variablesAreStable(vector* vVariables) { bool flagAllVariablesAreStable = true; for (auto &slot : *vVariables) { if (slot->getHistoryLength() >= slidingWindowBufferSize - 1) { //-1 because actual value is not in the history if (slot->getNumberOfRelativesToActualValue(thresholdToBeStable) < minNumOfRelatedValuesToBeStable) { //-1 because actual value is also on of minNumOfRelatedValuesToBeStable flagAllVariablesAreStable = false; } } else { return false; } } return flagAllVariablesAreStable; } //Sorting with bigger Value in Front struct descending { template bool operator()(T const &a, T const &b) const { return a > b; } }; //DATE18 float StateHandler::getConfVariableIsStable(SlaveAgentSlotOfAgent* variable) { float bestConfOf1Var = 0; float sample; if (variable->get_slaveAgentValue(&sample)) { list lHistoryTemporary = variable->getHistory(); vector vDeviations; for (auto &h : lHistoryTemporary) vDeviations.push_back(deviationValueReferenceValue(sample, h)); std::sort(std::begin(vDeviations), std::end(vDeviations)); //all adaptabilities within the history of one variable for (unsigned int numOfHistSamplesIncluded = 1; numOfHistSamplesIncluded <= vDeviations.size(); numOfHistSamplesIncluded++) { float worstConfOfHistSampleSet = 1; unsigned int histSampleCounter = 0; for (auto &deviation : vDeviations) { if (histSampleCounter >= numOfHistSamplesIncluded) break; worstConfOfHistSampleSet = minValueOf2Values(worstConfOfHistSampleSet, StabDeviation->getY(deviation)); histSampleCounter++; } bestConfOf1Var = maxValueOf2Values(bestConfOf1Var, minValueOf2Values(worstConfOfHistSampleSet, StabSamples->getY((float)histSampleCounter))); } } return bestConfOf1Var; } //DATE18 float StateHandler::getConfVariablesAreStable(vector* vVariables) { float worstConfOfAllVariables = 1; for (auto &slot : *vVariables) worstConfOfAllVariables = minValueOf2Values(worstConfOfAllVariables, getConfVariableIsStable(slot)); return worstConfOfAllVariables; } //DATE18 float StateHandler::getConfVariableIsUnstable(SlaveAgentSlotOfAgent* variable) { float bestConfOf1Var = 0; float sample; if (variable->get_slaveAgentValue(&sample)) { list lHistoryTemporary = variable->getHistory(); vector vDeviations; for (auto &h : lHistoryTemporary) vDeviations.push_back(deviationValueReferenceValue(sample, h)); sort(begin(vDeviations), end(vDeviations), descending()); //all adaptabilities within the history of one variable for (unsigned int numOfHistSamplesIncluded = 1; numOfHistSamplesIncluded <= vDeviations.size(); numOfHistSamplesIncluded++) { //float bestConfOfHistSampleSet = 1; float bestConfOfHistSampleSet = 0; unsigned int histSampleCounter = 0; for (auto &deviation : vDeviations) { if (histSampleCounter >= numOfHistSamplesIncluded) break; //bestConfOfHistSampleSet = minValueOf2Values(bestConfOfHistSampleSet, UnstabDeviation->getY(deviation)); bestConfOfHistSampleSet = maxValueOf2Values(bestConfOfHistSampleSet, UnstabDeviation->getY(deviation)); histSampleCounter++; } bestConfOf1Var = maxValueOf2Values(bestConfOf1Var, minValueOf2Values(bestConfOfHistSampleSet, StabSamples->getY((float)histSampleCounter))); } } return bestConfOf1Var; } //DATE18 - Is there one unstable variable? float StateHandler::getConfVariablesAreUnstable(vector* vVariables) { float bestConfOfAllVariables = 0; for (auto &slot : *vVariables) bestConfOfAllVariables = maxValueOf2Values(bestConfOfAllVariables, getConfVariableIsUnstable(slot)); return bestConfOfAllVariables; } - +/* bool StateHandler::getConfAndUnconfVariableIsMatching(State* state, LinearFunctionBlock* confDeviation, LinearFunctionBlock* confTime, float* conf, float* unconf) { float bestUnconfOf1Var = 0; float worstConfOf1Var = 1; if (state != NULL) { } - /* + float sample; if (variable->get_slaveAgentValue(&sample)) { list lHistoryTemporary = variable->getHistory(); vector vDeviations; for (auto &h : lHistoryTemporary) vDeviations.push_back(deviationValueReferenceValue(sample, h)); sort(begin(vDeviations), end(vDeviations), descending()); //all adaptabilities within the history of one variable for (unsigned int numOfHistSamplesIncluded = 1; numOfHistSamplesIncluded <= vDeviations.size(); numOfHistSamplesIncluded++) { //float bestConfOfHistSampleSet = 1; float bestConfOfHistSampleSet = 0; unsigned int histSampleCounter = 0; for (auto &deviation : vDeviations) { if (histSampleCounter >= numOfHistSamplesIncluded) break; //bestConfOfHistSampleSet = minValueOf2Values(bestConfOfHistSampleSet, UnstabDeviation->getY(deviation)); bestConfOfHistSampleSet = maxValueOf2Values(bestConfOfHistSampleSet, UnstabDeviation->getY(deviation)); histSampleCounter++; } bestConfOf1Var = maxValueOf2Values(bestConfOf1Var, minValueOf2Values(bestConfOfHistSampleSet, StabSamples->getY((float)histSampleCounter))); } } return bestConfOf1Var; - */ + return 0; } - +*/ /* bool StateHandler::getConfAndUnconfVariablesAreMatching(vector* vVariables, LinearFunctionBlock* confDeviation, LinearFunctionBlock* confTime, float* conf, float* unconf) { float bestUnconfOfAllVariables = 0; float worstConfOfAllVariables = 1; for (auto &variable :* vVariables) { bestUnconfOfAllVariables = maxValueOf2Values(bestUnconfOfAllVariables, getConfAndUnconfVariableIsMatching(variable, confDeviation, confTime, conf, unconf)); worstConfOfAllVariables = minValueOf2Values(worstConfOfAllVariables, getConfAndUnconfVariableIsMatching(variable, confDeviation, confTime, conf, unconf)); } *conf = worstConfOfAllVariables; *unconf = bestUnconfOfAllVariables; return true; } */ State* StateHandler::makeNewState() { State* state = new (nothrow) State(); if (state != NULL) { bool flagLoadVariablesWorked = true; for (auto &slot : vInputVariables) { if (!state->addInputSubState(slot)) flagLoadVariablesWorked = false; } for (auto &slot : vOutputVariables) { if (!state->addOutputSubState(slot)) flagLoadVariablesWorked = false; } if (!flagLoadVariablesWorked) { delete state; return NULL; } } else { return NULL; } return state; } bool StateHandler::addActiveStateToStateVector() { #ifdef PRINT printf(" >> Save Active State\n"); #endif //PRINT if (activeState != NULL) { for (auto &state : vStates) { if (state == activeState) return true; } #ifdef STOP_WHEN_STATE_VALID getchar(); #endif // STOP_WHEN_STATE_VALID try { vStates.push_back(activeState); return true; } catch (bad_alloc& error) { printError("bad_alloc caught: ", error.what()); delete activeState; } } return false; } /* bool StateHandler::addStateAndMakeItActive() { State* state = addState(); if (state != NULL) { activeState = state; return true; } return false; } */ bool StateHandler::makeNewActiveState() { State* state = makeNewState(); if (state != NULL) { activeState = state; return true; } return false; } State* StateHandler::findRelatedState() { for (auto &state : vStates) { if (state->inputVariablesAreRelated(thresholdToBeRelated) && state->outputVariablesAreRelated(thresholdToBeRelated)) { return state; } } return NULL; } bool StateHandler::findRelatedStateAndMakeItActive() { State* state = findRelatedState(); if (state != NULL) { activeState = state; return true; } return false; } void StateHandler::eraseStatesWithLessInjections() { if (activeState != NULL) { if (activeState->getNumOfInjections() < minNumToBeValidState) { activeState = NULL; } } for (vector::iterator state = vStates.begin(); state < vStates.end(); state++) { if ((*state)->getNumOfInjections() < minNumToBeValidState) { //TODO: also delete all subStates (etc.) of the State? Because: Memory Leakage. vStates.erase(state); state--; } } /* for (auto &state : vStates) { //TODO: also delete all subStates (etc.) of the State? Because: Memory Leakage. if (state->getNumOfInjections() < minNumToBeValidState) { vStates.erase(state); } } */ } void StateHandler :: reset_States() { this->delete_allStates(); this->activeState = NULL; } void StateHandler :: reset_States_and_Slave_Agents() { reset_States(); this->delete_all_InputVariables(); this->delete_all_OuputVariables(); } +void StateHandler ::setMaxStateHistoryLength( + unsigned int maxStateHistoryLength) { + this->maxStateHistoryLength = maxStateHistoryLength; +} + + + StateHandler :: ~StateHandler() { delete_all_OuputVariables(); delete_all_InputVariables(); delete_allStates(); //delete csv_writer; } //XXX - only for now bool test = true; unsigned int brokenCounter = 0, driftCounter = 0; void printDrift() { driftCounter++; setColor(TXTCOLOR_YELLOW); printf(" >> DRIFT\n"); setColor(TXTCOLOR_GREY); test = true; } void printBroken() { brokenCounter++; setColor(TXTCOLOR_LIGHTRED); printf(" >> BROKEN\n"); setColor(TXTCOLOR_GREY); test = true; } //XXX - only for now unsigned int old_cycle = 1; int brokentest = 0; /* * makes a new state and reports if there is a anomaly = hearth piece of CAM :-) */ void StateHandler::trigger(unsigned int cycle) { #ifdef PRINT printf("cycle: %u\n", cycle); #endif // PRINT bool flagGotValues = true; #ifdef PRINT printf("Input Sample Values:\n"); #endif // PRINT for (auto &slot : vInputVariables) { float sampleValue; if (!(slot->get_slaveAgentValue(&sampleValue))) flagGotValues = false; //program never executes this line of code #ifdef PRINT - printf("In, %s: %f\n", slot->get_comPort()->get_name(), sampleValue); + printf("In, %s: %f\n", slot->get_comPort()->get_name().c_str(), sampleValue); #endif // PRINT if (cycle == 1) - csv_writer->write_field(slot->get_comPort()->get_name()); + csv_writer->write_field(slot->get_comPort()->get_name().c_str()); else csv_writer->write_field(sampleValue); csv_writer->make_new_field(); } #ifdef PRINT printf("Output Sample Values:\n"); #endif // PRINT for (auto &slot : vOutputVariables) { float sampleValue; if (!(slot->get_slaveAgentValue(&sampleValue))) flagGotValues = false; //program never executes this line of code #ifdef PRINT - printf("Out, %s: %f\n", slot->get_comPort()->get_name(), sampleValue); + printf("Out, %s: %f\n", slot->get_comPort()->get_name().c_str(), sampleValue); #endif // PRINT if (cycle == 1) - csv_writer->write_field(slot->get_comPort()->get_name()); + csv_writer->write_field(slot->get_comPort()->get_name().c_str()); else csv_writer->write_field(sampleValue); csv_writer->make_new_field(); } if (cycle == 1){ csv_writer->write_field("State Nr"); csv_writer->make_new_field(); csv_writer->write_field("Conf State Valid"); csv_writer->make_new_field(); csv_writer->write_field("Conf State Invalid"); csv_writer->make_new_field(); csv_writer->write_field("Conf Input unchanged"); csv_writer->make_new_field(); csv_writer->write_field("Conf Input changed"); csv_writer->make_new_field(); csv_writer->write_field("Conf Output unchanged"); csv_writer->make_new_field(); csv_writer->write_field("Conf Output changed"); csv_writer->make_new_field(); csv_writer->write_field("Status"); csv_writer->make_new_field(); csv_writer->write_field("Conf Status"); csv_writer->make_new_field(); } else { //in the beginning, a active state has to be created if (activeState == NULL && vStates.empty()) { brokenCounter = 0; #ifdef PRINT printf(" > new active state\n"); #endif // PRINT makeNewActiveState(); if (activeState->insertValueInState(FuncBlockConfValStateDev, FuncBlockConfInvStateDev, FuncBlockConfValStateTime, FuncBlockConfInvStateTime, maxStateHistoryLength, discreteAveragePartitionSize)) addActiveStateToStateVector(); //NEW - Adjust FuncBlockConfSim2StateTime and FuncBlockConfDif2StateTime float newBoundary = (float)activeState->getLengthOfHistory(); FuncBlockConfSim2StateTime->changeFunctionBlockIncr(newBoundary); FuncBlockConfDif2StateTime->changeFunctionBlockDecr(newBoundary); csv_writer->write_field((int)vStates.size() + 1); csv_writer->make_new_field(); csv_writer->write_field(activeState->getConfStateValid()); csv_writer->make_new_field(); csv_writer->write_field(activeState->getConfStateInvalid()); csv_writer->make_new_field(); csv_writer->write_field(0); //confInputVarAreSim2ActiveState csv_writer->make_new_field(); csv_writer->write_field(0); //confInputVarAreDif2ActiveState csv_writer->make_new_field(); csv_writer->write_field(0); //confOutputVarAreSim2ActiveState csv_writer->make_new_field(); csv_writer->write_field(0); //confOutputVarAreDif2ActiveState csv_writer->make_new_field(); csv_writer->write_field(STATUS_OKAY); csv_writer->make_new_field(); csv_writer->write_field(0); //Status Conf csv_writer->make_new_field(); } //there is an active state and/or other states else { float confInputVarAreSim2ActiveState = activeState->getConfInputVarAreSim2State(FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime); float confInputVarAreDif2ActiveState = activeState->getConfInputVarAreDif2State(FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime); float confOutputVarAreSim2ActiveState = activeState->getConfOutputVarAreSim2State(FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime); float confOutputVarAreDif2ActiveState = activeState->getConfOutputVarAreDif2State(FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime); - float confInputIsSteady = confInputVarAreSim2ActiveState - confInputVarAreDif2ActiveState; - float confOutputIsSteady = confOutputVarAreSim2ActiveState - confOutputVarAreDif2ActiveState; + //float confInputIsSteady = confInputVarAreSim2ActiveState - confInputVarAreDif2ActiveState; + //float confOutputIsSteady = confOutputVarAreSim2ActiveState - confOutputVarAreDif2ActiveState; printf("input (sim/dif) %f/%f\noutput (sim/dif) %f/%f\n", confInputVarAreSim2ActiveState, confInputVarAreDif2ActiveState, confOutputVarAreSim2ActiveState, confOutputVarAreDif2ActiveState); //same state if ((confInputVarAreSim2ActiveState > confInputVarAreDif2ActiveState) && (confOutputVarAreSim2ActiveState > confOutputVarAreDif2ActiveState)) { brokenCounter = 0; #ifdef PRINT printf(" > same state\n"); //printf("\nPROOF:\nconfInputVarAreSim2ActiveState = %f\nconfInputVarAreDif2ActiveState = %f\nconfOutputVarAreSim2ActiveState = %f\nconfOutputVarAreDif2ActiveState = %f\n", confInputVarAreSim2ActiveState, confInputVarAreDif2ActiveState, confOutputVarAreSim2ActiveState, confOutputVarAreDif2ActiveState); #endif // PRINT if (activeState->insertValueInState(FuncBlockConfValStateDev, FuncBlockConfInvStateDev, FuncBlockConfValStateTime, FuncBlockConfInvStateTime, maxStateHistoryLength, discreteAveragePartitionSize)) addActiveStateToStateVector(); //NEW - Adjust FuncBlockConfSim2StateTime and FuncBlockConfDif2StateTime float newBoundary = (float)activeState->getLengthOfHistory(); FuncBlockConfSim2StateTime->changeFunctionBlockIncr(newBoundary); FuncBlockConfDif2StateTime->changeFunctionBlockDecr(newBoundary); //print state number if(activeState->isStateValid()) csv_writer->write_field((int)vStates.size()); else csv_writer->write_field((int)vStates.size()+1); csv_writer->make_new_field(); //print conf valid csv_writer->write_field(activeState->getConfStateValid()); csv_writer->make_new_field(); csv_writer->write_field(activeState->getConfStateInvalid()); csv_writer->make_new_field(); //print conf statechange csv_writer->write_field(confInputVarAreSim2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confInputVarAreDif2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confOutputVarAreSim2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confOutputVarAreDif2ActiveState); csv_writer->make_new_field(); confidenceDrift = activeState->checkAllVariablesForDriftingFuzzy(discreteAveragePartitionSize, DriftDeviation); float confidenceNoDrift = 1 - confidenceDrift; /* //print conf drift csv_writer->write_field(confidenceNoDrift); csv_writer->make_new_field(); csv_writer->write_field(confidenceDrift); csv_writer->make_new_field(); */ if (confidenceDrift > 0.5) { #ifdef PRINT setColor(TXTCOLOR_YELLOW); printf("DRIFT\n"); setColor(TXTCOLOR_GREY); #endif // PRINT #ifdef STOP_WHEN_DRIFT getchar(); #endif // STOP_WHEN_DRIFT setColor(TXTCOLOR_GREY); //print drift csv_writer->write_field(STATUS_DRIFT); csv_writer->make_new_field(); //calc and print conf float conf = fuzzyAND(fuzzyAND(confidenceDrift, activeState->getConfStateValid()), fuzzyAND(confInputVarAreSim2ActiveState, confOutputVarAreSim2ActiveState)); csv_writer->write_field(conf); } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTGREEN); printf("OK\n"); setColor(TXTCOLOR_GREY); #endif // PRINT //print ok csv_writer->write_field(STATUS_OKAY); csv_writer->make_new_field(); //calc and print conf float conf = fuzzyAND(fuzzyAND(confInputVarAreSim2ActiveState, confOutputVarAreSim2ActiveState), fuzzyAND(activeState->getConfStateValid(), confidenceNoDrift)); csv_writer->write_field(conf); } csv_writer->make_new_field(); } //state change else { //was Valid if (activeState->isStateValid()) { //only one sub set changed if (((confInputVarAreSim2ActiveState > confInputVarAreDif2ActiveState) && (confOutputVarAreSim2ActiveState <= confOutputVarAreDif2ActiveState)) || ((confInputVarAreSim2ActiveState <= confInputVarAreDif2ActiveState) && (confOutputVarAreSim2ActiveState > confOutputVarAreDif2ActiveState))) { //print state number if (activeState->isStateValid()) csv_writer->write_field((int)vStates.size()); else csv_writer->write_field((int)vStates.size() + 1); csv_writer->make_new_field(); //print conf valid csv_writer->write_field(activeState->getConfStateValid()); csv_writer->make_new_field(); csv_writer->write_field(activeState->getConfStateInvalid()); csv_writer->make_new_field(); //print conf statechange csv_writer->write_field(confInputVarAreSim2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confInputVarAreDif2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confOutputVarAreSim2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confOutputVarAreDif2ActiveState); csv_writer->make_new_field(); brokenCounter++; printf("brokenCounter: %u\n", brokenCounter); confidenceBroken = FuncBlockConfBrokenSamples->getY((float) brokenCounter); float confidenceOK = 1 - confidenceBroken; if (confidenceBroken > 0.5) { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf("BROKEN\n"); setColor(TXTCOLOR_GREY); #endif // PRINT #ifdef STOP_AFTER_BROKEN brokentest = 1; #endif // STOP_AFTER_BROKEN #ifdef STOP_WHEN_BROKEN getchar(); #endif // STOP_WHEN_BROKEN //print broken csv_writer->write_field(STATUS_BROKEN); csv_writer->make_new_field(); //calculate and print conf float conf = fuzzyAND(fuzzyOR(confInputVarAreDif2ActiveState, confOutputVarAreDif2ActiveState), fuzzyAND(confidenceBroken, activeState->getConfStateValid())); csv_writer->write_field(conf); //csv_writer->make_new_field(); } else { //print ok csv_writer->write_field(STATUS_OKAY); csv_writer->make_new_field(); //calculate and print conf float conf = fuzzyAND(fuzzyOR(fuzzyAND(confInputVarAreSim2ActiveState, confOutputVarAreSim2ActiveState), fuzzyAND(confInputVarAreDif2ActiveState, confOutputVarAreDif2ActiveState)), fuzzyAND(confidenceOK, activeState->getConfStateValid())); csv_writer->write_field(conf); } } //In- and output changed else { brokenCounter = 0; printf(" > delete active state\n"); activeState = NULL; printf(" > new active state\n"); // search in vector for matching state //TODO in future: look for the best matching, Not for the first matching bool flagFoundMatchingState = false; float confInputVarAreSim2ActiveState; float confInputVarAreDif2ActiveState; float confOutputVarAreSim2ActiveState; float confOutputVarAreDif2ActiveState; for (auto &state : vStates) { confInputVarAreSim2ActiveState = state->getConfInputVarAreSim2State(FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime); confInputVarAreDif2ActiveState = state->getConfInputVarAreDif2State(FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime); confOutputVarAreSim2ActiveState = state->getConfOutputVarAreSim2State(FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime); confOutputVarAreDif2ActiveState = state->getConfOutputVarAreDif2State(FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime); if ((confInputVarAreSim2ActiveState > confInputVarAreDif2ActiveState) && (confOutputVarAreSim2ActiveState > confOutputVarAreDif2ActiveState)) { activeState = state; flagFoundMatchingState = true; } } if (flagFoundMatchingState == false) { makeNewActiveState(); confInputVarAreSim2ActiveState = 0; confInputVarAreDif2ActiveState = 0; confOutputVarAreSim2ActiveState = 0; confOutputVarAreDif2ActiveState = 0; } //insert in activeState if (activeState->insertValueInState(FuncBlockConfValStateDev, FuncBlockConfInvStateDev, FuncBlockConfValStateTime, FuncBlockConfInvStateTime, maxStateHistoryLength, discreteAveragePartitionSize)) addActiveStateToStateVector(); //NEW - Adjust FuncBlockConfSim2StateTime and FuncBlockConfDif2StateTime float newBoundary = (float)activeState->getLengthOfHistory(); FuncBlockConfSim2StateTime->changeFunctionBlockIncr(newBoundary); FuncBlockConfDif2StateTime->changeFunctionBlockDecr(newBoundary); //print state number if (activeState->isStateValid()) csv_writer->write_field((int)vStates.size()); else csv_writer->write_field((int)vStates.size() + 1); csv_writer->make_new_field(); //print conf valid csv_writer->write_field(activeState->getConfStateValid()); csv_writer->make_new_field(); csv_writer->write_field(activeState->getConfStateInvalid()); csv_writer->make_new_field(); //print conf statechange csv_writer->write_field(confInputVarAreSim2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confInputVarAreDif2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confOutputVarAreSim2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confOutputVarAreDif2ActiveState); csv_writer->make_new_field(); confidenceDrift = activeState->checkAllVariablesForDriftingFuzzy(discreteAveragePartitionSize, DriftDeviation); float confidenceNoDrift = 1 - confidenceDrift; if (confidenceDrift > 0.5) { setColor(TXTCOLOR_YELLOW); printf("DRIFT\n"); #ifdef STOP_WHEN_DRIFT getchar(); #endif // STOP_WHEN_DRIFT setColor(TXTCOLOR_GREY); //print drift csv_writer->write_field(STATUS_DRIFT); csv_writer->make_new_field(); //calc and print conf float conf = fuzzyAND(confidenceDrift, activeState->getConfStateValid()); csv_writer->write_field(conf); } else { setColor(TXTCOLOR_LIGHTGREEN); printf("OK\n"); setColor(TXTCOLOR_GREY); //print ok csv_writer->write_field(STATUS_OKAY); csv_writer->make_new_field(); //calc and print conf float conf = fuzzyAND(fuzzyAND(confInputVarAreDif2ActiveState, confOutputVarAreDif2ActiveState), fuzzyAND(activeState->getConfStateValid(), confidenceNoDrift)); csv_writer->write_field(conf); } csv_writer->make_new_field(); } } //was NOT Valid else { brokenCounter = 0; printf(" > delete active state\n"); delete activeState; activeState = NULL; printf(" > new active state\n"); // search in vector for matching state //TODO in future: look for the best matching, Not for the first matching bool flagFoundMatchingState = false; float confInputVarAreSim2ActiveState; float confInputVarAreDif2ActiveState; float confOutputVarAreSim2ActiveState; float confOutputVarAreDif2ActiveState; for (auto &state : vStates) { confInputVarAreSim2ActiveState = state->getConfInputVarAreSim2State(FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime); confInputVarAreDif2ActiveState = state->getConfInputVarAreDif2State(FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime); confOutputVarAreSim2ActiveState = state->getConfOutputVarAreSim2State(FuncBlockConfSim2StateDev, FuncBlockConfSim2StateTime); confOutputVarAreDif2ActiveState = state->getConfOutputVarAreDif2State(FuncBlockConfDif2StateDev, FuncBlockConfDif2StateTime); if ((confInputVarAreSim2ActiveState > confInputVarAreDif2ActiveState) && (confOutputVarAreSim2ActiveState > confOutputVarAreDif2ActiveState)) { activeState = state; flagFoundMatchingState = true; } } if (flagFoundMatchingState == false) { makeNewActiveState(); confInputVarAreSim2ActiveState = 0; confInputVarAreDif2ActiveState = 0; confOutputVarAreSim2ActiveState = 0; confOutputVarAreDif2ActiveState = 0; } //insert in active state if (activeState->insertValueInState(FuncBlockConfValStateDev, FuncBlockConfInvStateDev, FuncBlockConfValStateTime, FuncBlockConfInvStateTime, maxStateHistoryLength, discreteAveragePartitionSize)) addActiveStateToStateVector(); //NEW - Adjust FuncBlockConfSim2StateTime and FuncBlockConfDif2StateTime float newBoundary = (float)activeState->getLengthOfHistory(); FuncBlockConfSim2StateTime->changeFunctionBlockIncr(newBoundary); FuncBlockConfDif2StateTime->changeFunctionBlockDecr(newBoundary); //print state number if (activeState->isStateValid()) csv_writer->write_field((int)vStates.size()); else csv_writer->write_field((int)vStates.size() + 1); csv_writer->make_new_field(); //print conf valid csv_writer->write_field(activeState->getConfStateValid()); csv_writer->make_new_field(); csv_writer->write_field(activeState->getConfStateInvalid()); csv_writer->make_new_field(); //print conf statechange csv_writer->write_field(confInputVarAreSim2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confInputVarAreDif2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confOutputVarAreSim2ActiveState); csv_writer->make_new_field(); csv_writer->write_field(confOutputVarAreDif2ActiveState); csv_writer->make_new_field(); confidenceDrift = activeState->checkAllVariablesForDriftingFuzzy(discreteAveragePartitionSize, DriftDeviation); float confidenceNoDrift = 1 - confidenceDrift; if (confidenceDrift > 0.5) { setColor(TXTCOLOR_YELLOW); printf("DRIFT\n"); #ifdef STOP_WHEN_DRIFT getchar(); #endif // STOP_WHEN_DRIFT setColor(TXTCOLOR_GREY); //print drift csv_writer->write_field(2); csv_writer->make_new_field(); //calc and print conf float conf = fuzzyAND(confidenceDrift, activeState->getConfStateValid()); csv_writer->write_field(conf); } else { setColor(TXTCOLOR_LIGHTGREEN); printf("OK\n"); setColor(TXTCOLOR_GREY); //print ok csv_writer->write_field(STATUS_OKAY); csv_writer->make_new_field(); //calc and print conf float conf = fuzzyAND(fuzzyAND(confInputVarAreDif2ActiveState, confOutputVarAreDif2ActiveState), fuzzyAND(activeState->getConfStateValid(), confidenceNoDrift)); csv_writer->write_field(conf); } csv_writer->make_new_field(); } } #ifdef PRINT printf("STATES: %u\n", vStates.size()); #endif // PRINT } } csv_writer->make_new_line(); if (brokentest) getchar(); /* //XXX - only for now for (unsigned int i = 1; i < (cycle - old_cycle); i++) { csv_writer->make_new_field(); csv_writer->make_new_field(); csv_writer->make_new_field(); csv_writer->make_new_line(); //printf("%u\n", i); } old_cycle = cycle; confidenceStableInput = getConfVariablesAreStable(&vInputVariables); confidenceStableOutput = getConfVariablesAreStable(&vOutputVariables); confidenceStable = minValueOf2Values(confidenceStableInput, confidenceStableOutput); printf("confidence stable: %f\n", confidenceStable); confidenceUnstableInput = getConfVariablesAreUnstable(&vInputVariables); confidenceUnstableOutput = getConfVariablesAreUnstable(&vOutputVariables); printf("unstable In: %f, Out: %f\n", confidenceUnstableInput, confidenceUnstableOutput); confidenceUnstable = maxValueOf2Values(confidenceUnstableInput, confidenceUnstableOutput); printf("confidence unstable: %f\n", confidenceUnstable); if (confidenceUnstableInput > 0) { printf("jetzt\n"); getchar(); } //TEST if (confidenceStable > confidenceUnstable) { setColor(TXTCOLOR_LIGHTBLUE); printf("jetzt\n"); setColor(TXTCOLOR_GREY); getchar(); } //getchar(); if (confidenceStable > confidenceUnstable) { //if (false) { printf(" > stable\n"); //for the beginning (there is no state available/created) -> create state if (activeState == NULL && vStates.empty()) { printf(" > new state\n"); makeNewActiveState(); activeState->injectValues(discreteAveragePartitionSize); confidenceValidState = ValidState->getY((float)activeState->getNumOfInjections()); } //there is an active state else if (activeState != NULL) { //caclulate confidences of deciding for same state float confidenceSameStateInput = activeState->inputVariablesAreRelatedFuzzy(SameState); float confidenceSameStateOutput = activeState->outputVariablesAreRelatedFuzzy(SameState); printf("ConfSameState\nIn: %f\nout: %f\n", confidenceSameStateInput, confidenceSameStateOutput); //In- and Outputs are unchanged if ((confidenceSameStateInput > confSameStateInputAdjustableThreshold) && (confidenceSameStateOutput > confSameStateOutputAdjustableThreshold)) { printf(" > same state\n"); //inject values activeState->injectValues(discreteAveragePartitionSize); //calculate the confidence to have a validState confidenceValidState = ValidState->getY((float)activeState->getNumOfInjections()); //TODO DATE //check for drifting!!! //printDrift(); } //In- and Outputs have changed else if ((confidenceSameStateInput <= confSameStateInputAdjustableThreshold) && (confidenceSameStateOutput <= confSameStateOutputAdjustableThreshold)) { printf(" > change state\n"); getchar(); //active state is/was valid if (confidenceValidState > confValidStateAdjustableThreshold) { printf("speicher\n"); getchar(); addActiveStateToStateVector(); //TODO DATE //search for matching state //or printf(" > new state\n"); //create an new active state makeNewActiveState(); //inject values activeState->injectValues(discreteAveragePartitionSize); //calculate the confidence to have a validState confidenceValidState = ValidState->getY((float)activeState->getNumOfInjections()); //TODO DATE //check for drifting!!! //printDrift(); } } //Only in- or outputs have changed else { //active state is/was valid if (confidenceValidState > confValidStateAdjustableThreshold) { addActiveStateToStateVector(); printf(" > broken\n"); brokenCounter++; confidenceBroken = BrokenCounterSamples->getY(brokenCounter); //getchar(); //TODO DATE?? //Save State } } } //there is no active state, but there is/are state(s) else { printf(" > old or new state\n"); //getchar(); //TODO DATE //search for matching state //or printf(" > new state\n"); makeNewActiveState(); activeState->injectValues(discreteAveragePartitionSize); confidenceValidState = ValidState->getY((float)activeState->getNumOfInjections()); //TODO DATE //check for drifting!!! //printDrift(); } if (activeState != NULL) { confidenceDrift = activeState->checkAllVariablesForDriftingFuzzy(discreteAveragePartitionSize, DriftDeviation); } //getchar(); } //unstable else { printf(" > unstable\n"); //there is/was an active state if (activeState != NULL) { //delete activeState; if (confidenceValidState > confValidStateAdjustableThreshold) addActiveStateToStateVector(); activeState = NULL; } } //DATE TODO //STABLE CONFIDENCE MITEINBEZIEHEN if ((confidenceBroken >= confidenceBroken) && (confidenceBroken > confidenceBrokenAdjustableThreshold)) { setColor(TXTCOLOR_LIGHTRED); printf(" >> BROKEN - confidence %f\n", confidenceBroken); setColor(TXTCOLOR_GREY); getchar(); } else if (confidenceDrift > confidenceDriftAdjustableThreshold) { setColor(TXTCOLOR_YELLOW); printf(" >> DRIFT - confidence %f\n", confidenceDrift); setColor(TXTCOLOR_GREY); //XXXXXXXXXX ???????????????????????????????????? if (brokenCounter > 0) brokenCounter--; getchar(); } else { setColor(TXTCOLOR_LIGHTGREEN); float confidenceOK; if (confidenceDrift > confidenceBroken) confidenceOK = 1 - confidenceDrift; else confidenceOK = 1 - confidenceBroken; printf(" >> SYSTEM OK - confidence %f\n", confidenceOK); setColor(TXTCOLOR_GREY); } printf("brokenCounter %u\n", brokenCounter); printf("number of states: %i\n", vStates.size()); */ /* if (variablesAreStable(&vInputVariables) && variablesAreStable(&vOutputVariables)) { printf(" > stable\n"); //XXX - only for now csv_writer->write_field(2); //stable csv_writer->make_new_field(); //getchar(); if (activeState == NULL && vStates.empty()) { makeNewActiveState(); activeState->injectValues(discreteAveragePartitionSize); //XXX - only for now csv_writer->write_field(1); //new active state csv_writer->make_new_field(); csv_writer->make_new_field(); } else { if (activeState != NULL) { printf("\nbeginning here:\n"); bool flagInputUnchanged = activeState->inputVariablesAreRelated(thresholdToBeRelated); bool flagOutputUnchanged = activeState->outputVariablesAreRelated(thresholdToBeRelated); //input and/or output unchanged? if (flagInputUnchanged && flagOutputUnchanged) { activeState->injectValues(discreteAveragePartitionSize); if (!activeState->checkAllVariablesForNotDrifting(discreteAveragePartitionSize, compareDistanceDiscreteAveragePartition, thresholdNotDrift)) { printDrift(); //XXX - only for now csv_writer->make_new_field(); csv_writer->write_field(1); //drift csv_writer->make_new_field(); } //XXX - only for now else { csv_writer->make_new_field(); csv_writer->make_new_field(); } } else { if (activeState->getNumOfInjections() >= minNumToBeValidState) { if ((!flagInputUnchanged && flagOutputUnchanged) || (flagInputUnchanged && !flagOutputUnchanged)) { printBroken(); getchar(); //XXX - only for now csv_writer->make_new_field(); csv_writer->write_field(2); //broken csv_writer->make_new_field(); } else { addActiveStateToStateVector(); if (!findRelatedStateAndMakeItActive()) { makeNewActiveState(); activeState->injectValues(discreteAveragePartitionSize); //XXX - only for now csv_writer->write_field(1); //new active state csv_writer->make_new_field(); csv_writer->make_new_field(); } else { //next line is new activeState->resetDiscreteAveragePartitionCounter(); //XXX - only for now csv_writer->write_field(2); //change to existing state csv_writer->make_new_field(); activeState->injectValues(discreteAveragePartitionSize); if (!activeState->checkAllVariablesForNotDrifting(discreteAveragePartitionSize, compareDistanceDiscreteAveragePartition, thresholdNotDrift)) { printDrift(); //XXX - only for now csv_writer->write_field(1); //drift csv_writer->make_new_field(); } //XXX - only for now else { csv_writer->make_new_field(); } } } } else { delete activeState; if (!findRelatedStateAndMakeItActive()) { makeNewActiveState(); activeState->injectValues(discreteAveragePartitionSize); //XXX - only for now csv_writer->write_field(1); //new active state csv_writer->make_new_field(); csv_writer->make_new_field(); } else { //next line is new activeState->resetDiscreteAveragePartitionCounter(); //XXX - only for now csv_writer->write_field(2); //change to existing state csv_writer->make_new_field(); activeState->injectValues(discreteAveragePartitionSize); if (!activeState->checkAllVariablesForNotDrifting(discreteAveragePartitionSize, compareDistanceDiscreteAveragePartition, thresholdNotDrift)) { printDrift(); //XXX - only for now csv_writer->write_field(1); //drift csv_writer->make_new_field(); } //XXX - only for now else { csv_writer->make_new_field(); } } } } } else { if (!findRelatedStateAndMakeItActive()) { makeNewActiveState(); activeState->injectValues(discreteAveragePartitionSize); //XXX - only for now csv_writer->write_field(1); //new active state csv_writer->make_new_field(); csv_writer->make_new_field(); } else { //next line is new activeState->resetDiscreteAveragePartitionCounter(); //XXX - only for now csv_writer->write_field(2); //change to existing state csv_writer->make_new_field(); activeState->injectValues(discreteAveragePartitionSize); if (!activeState->checkAllVariablesForNotDrifting(discreteAveragePartitionSize, compareDistanceDiscreteAveragePartition, thresholdNotDrift)) { printDrift(); //XXX - only for now csv_writer->write_field(1); //drift csv_writer->make_new_field(); } //XXX - only for now else { csv_writer->make_new_field(); } } } } if (activeState != NULL) { printf(" -- an activeState exist: \n"); printf(" --- injections: %u\n", activeState->getNumOfInjections()); //XXX - only for now csv_writer->write_field((int)activeState->getNumOfInjections()); //number of injections csv_writer->make_new_line(); } //XXX - only for now else { csv_writer->make_new_field(); } printf(" -- Number of States (excl. activeState): %u\n", vStates.size()); for (auto &s : vStates) { printf(" --- injections: %u\n", s->getNumOfInjections()); } printf(" ... BrokenCounter: %u\n", brokenCounter); printf(" ... driftCounter: %u\n", driftCounter); printf("cycle: %u\n", cycle); if (test) { test = false; //getchar(); } flagVariablesWereStable = true; } else { printf(" > unstable\n"); //XXX - only for now csv_writer->write_field(1); //unstable csv_writer->make_new_field(); csv_writer->make_new_field(); csv_writer->make_new_field(); csv_writer->make_new_line(); if (flagVariablesWereStable) test = true; //search for states with less injections in all states if (flagVariablesWereStable) { if (activeState != NULL) { if (activeState->getNumOfInjections() >= minNumToBeValidState) { addActiveStateToStateVector(); } else { delete activeState; } activeState = NULL; //getchar(); } } flagVariablesWereStable = false; } //xxx - only for now //csv_writer->make_new_line(); */ } void StateHandler::closeCsvFile() { if(csv_writer != NULL) csv_writer->close_file(); } string StateHandler::create_Output_File_Name(string cfg_parameter) { time_t rawtime; struct tm * timeinfo; - char output_file_name[200]; + //char output_file_name[200]; char datetime[80]; std::string output_file_name_str; time(&rawtime); timeinfo = localtime(&rawtime); strftime(datetime, sizeof(datetime), "%Y-%m-%d_%I-%M-%S", timeinfo); #ifndef INPUT_FILE_NAME output_file_name_str = output_directory_name + "output" + datetime + cfg_parameter + ".csv"; #else string out_dir = "../data/out/"; output_file_name_str = out_dir + INPUT_FILE_NAME + datetime + cfg_parameter + ".csv"; #endif // INPUT_FILE_NAME return output_file_name_str; } void StateHandler::set_CSV_Writer_parameter(string cfg_parameter) { string cur_Output_File_Name = this->create_Output_File_Name(cfg_parameter); csv_writer->reset_fpointer(cur_Output_File_Name); } /* void StateHandler :: initStateHandler() { //activeState = NULL; thresholdToAverage = THRESHOLDTOAVG; minNumOfChangedForValidStateChange = MINNUMCHANGEDFORVALIDSTATECHANGE; minimumInjectionsForBeingState = MININJFORBEINGSTATE; } StateHandler :: StateHandler() { set_name(NO_NAME); initStateHandler(); } StateHandler :: StateHandler(char* name) { set_name(name); initStateHandler(); } bool StateHandler :: setMinimumInjectionsForBeingState(unsigned int minimumInjectionsForBeingState) { if (minimumInjectionsForBeingState > 0) { this->minimumInjectionsForBeingState = minimumInjectionsForBeingState; return true; } return false; } unsigned int StateHandler :: getMinimumInjectionsForBeingState() { return minimumInjectionsForBeingState; } bool StateHandler :: add_slot(SlaveAgentSlotOfAgent* slot) { if(slot != NULL) { try { vSlots.push_back(slot); return true; } catch(bad_alloc& error) { printError("bad_alloc caught: ", error.what()); delete slot; } } return false; } void StateHandler :: setThresholdToAverage(float thresholdToAverage) { this->thresholdToAverage = thresholdToAverage; } float StateHandler :: getThresholdToAverage() { return thresholdToAverage; } void StateHandler::set_minNumOfChangedForValidStateChange(unsigned int minNumOfChangedForValidStateChange) { this->minNumOfChangedForValidStateChange = minNumOfChangedForValidStateChange; } unsigned int StateHandler::get_minNumOfChangedForValidStateChange() { return minNumOfChangedForValidStateChange; } bool StateHandler :: trigger() { bool flagWorked = true; printf("NumOfStates: "); for (auto &slot : vSlots) { printf("%u, ", slot->getNumberOfStates()); } printf("\n"); //Check all input values if they have changed more than threshold ...and count how many changed unsigned int numberOfChanges = 0; for (auto &slot : vSlots) { float value; if (slot->get_slaveAgentValue(&value)) { State* activeState = slot->getActiveState(); if (activeState != NULL) { printf("act - "); if (activeState->isNew()) { printf("new - "); //numberOfChanges++; } else if (activeState->valueIsRelated(value, thresholdToAverage)) { printf("rel - "); } else { printf("nrel - "); numberOfChanges++; } } else { printf("nact - "); } } } printf("\n"); printf(" >> Number of Changes: %u\n", numberOfChanges); //nothing has changes more than threshold if (numberOfChanges == 0) { printf("\n\n >>> inject in active state\n"); for (auto &slot : vSlots) { slot->injectValueInActiveState(); } } else if(numberOfChanges >= minNumOfChangedForValidStateChange) { printf("\n\n >>> new (or another) state\n"); for (auto &slot : vSlots) { State* activeState = slot->getActiveState(); if (activeState != NULL) { if (activeState->getNumberOfInjections() < minimumInjectionsForBeingState) { slot->deleteActiveState(); printf(" >> delete State\n"); } } } //search for existing state bool flagRelated = false; if (vSlots.empty() == false) { int ix = vSlots.front()->getIndexOfRelatedState(0, thresholdToAverage); while (ix > -2) { if (ix >= 0) { //TODO: maybe another state fits a bit better.. approach -> euklidean distance? flagRelated = true; for (vector::iterator slot = vSlots.begin() + 1; slot < vSlots.end(); slot++) { if ((*slot)->valueIsRelated(ix, thresholdToAverage) == false) { flagRelated = false; } } if (flagRelated == true) { for (auto &slot : vSlots) { slot->setActiveState(ix); } break; } ix = vSlots.front()->getIndexOfRelatedState(ix+1, thresholdToAverage); } } } if (flagRelated == false) { printf(" >> No related state found\n"); printf("\n\n >>> inject in active state\n"); for (auto &slot : vSlots) { slot->injectValueInActiveState(); } } } printf("ende\n"); return false; } */ diff --git a/Version_Max_07_05_2018_CMake/src/StateHandler.h b/Version_Max_07_05_2018_CMake/src/StateHandler.h index 6d07826..e8e64a2 100755 --- a/Version_Max_07_05_2018_CMake/src/StateHandler.h +++ b/Version_Max_07_05_2018_CMake/src/StateHandler.h @@ -1,195 +1,198 @@ #ifndef STATEHANDLER_HEADERFILE #define STATEHANDLER_HEADERFILE #include "Module.h" #include "SlaveAgentSlotOfAgent.h" #include "State.h" #include "StateVariable.h" #include //XXX - only for now #include "CSV_Writer.h" #include "LinearFunctionBlock.h" using namespace std; class StateHandler : public Module { public: LinearFunctionBlock* StabSamples; LinearFunctionBlock* StabDeviation; LinearFunctionBlock* UnstabDeviation; LinearFunctionBlock* SameState; LinearFunctionBlock* DriftDeviation; LinearFunctionBlock* BrokenCounterSamples; LinearFunctionBlock* ValidState; //NEU: //compare LinearFunctionBlock* FuncBlockConfSim2StateDev; LinearFunctionBlock* FuncBlockConfDif2StateDev; LinearFunctionBlock* FuncBlockConfSim2StateTime; LinearFunctionBlock* FuncBlockConfDif2StateTime; //insert LinearFunctionBlock* FuncBlockConfValStateDev; LinearFunctionBlock* FuncBlockConfInvStateDev; LinearFunctionBlock* FuncBlockConfValStateTime; LinearFunctionBlock* FuncBlockConfInvStateTime; LinearFunctionBlock* FuncBlockConfBrokenSamples; private: //DATE18 //XXX - >0,5? //discreate Average Partition Size adjustable? float confidenceStableInput; float confidenceStableOutput; float confidenceStable; float confStableAdjustableThreshold; float confidenceUnstableInput; float confidenceUnstableOutput; float confidenceUnstable; float confidenceUnstableAdjustableThreshold; float confidenceSameStateInput; float confSameStateInputAdjustableThreshold; float confidenceSameStateOutput; float confSameStateOutputAdjustableThreshold; float confidenceValidState; float confValidStateAdjustableThreshold; unsigned int brokenCounter; float confidenceBroken; float confidenceBrokenAdjustableThreshold; unsigned int driftCounter; float confidenceDrift; float confidenceDriftAdjustableThreshold; //XXX - Maybe Object "StateVariable" between StateHandler and Slot?! vector vInputVariables; vector vOutputVariables; vector vStates; State* activeState; unsigned int minNumToBeValidState; bool flagVariablesWereStable; unsigned int slidingWindowBufferSize; unsigned int minNumOfRelatedValuesToBeStable; float thresholdToBeStable; float thresholdToBeRelated; unsigned int discreteAveragePartitionSize; unsigned int compareDistanceDiscreteAveragePartition; float thresholdNotDrift; unsigned int maxStateHistoryLength; void initStateHandler(); bool addVariable(vector* vVariables, SlaveAgentSlotOfAgent* slot); bool variablesAreStable(vector* vVariables); //DATE18 float getConfVariableIsStable(SlaveAgentSlotOfAgent* variable); float getConfVariablesAreStable(vector* vVariables); float getConfVariableIsUnstable(SlaveAgentSlotOfAgent* variable); float getConfVariablesAreUnstable(vector* vVariables); //bool getConfAndUnconfVariableIsMatching(SlaveAgentSlotOfAgent* variable, LinearFunctionBlock* confDeviation, LinearFunctionBlock* confTime, float* conf, float* unconf); - bool getConfAndUnconfVariableIsMatching(State* state, LinearFunctionBlock* confDeviation, LinearFunctionBlock* confTime, float* conf, float* unconf); - bool getConfAndUnconfVariablesAreMatching(vector* vVariables, LinearFunctionBlock* confDeviation, LinearFunctionBlock* confTime, float* conf, float* unconf); + //bool getConfAndUnconfVariableIsMatching(State* state, LinearFunctionBlock* confDeviation, LinearFunctionBlock* confTime, float* conf, float* unconf); + //bool getConfAndUnconfVariablesAreMatching(vector* vVariables, LinearFunctionBlock* confDeviation, LinearFunctionBlock* confTime, float* conf, float* unconf); State* makeNewState(); string create_Output_File_Name(string cfg_Parameter); bool addActiveStateToStateVector(); //bool addStateAndMakeItActive(); bool makeNewActiveState(); State* findRelatedState(); bool findRelatedStateAndMakeItActive(); void eraseStatesWithLessInjections(); bool delete_all_OuputVariables(); bool delete_all_InputVariables(); bool delete_allStates(); //XXX - only for now: CSV_Writer *csv_writer; public: StateHandler(); - StateHandler(char* name); + StateHandler(std::string name); + StateHandler(std::string name, std::string csvWriterPath); bool setDiscreteAveragePartitionSize(unsigned int discreteAverage); unsigned int getDiscreteAveragePartitionSize(); bool addInputVariable(SlaveAgentSlotOfAgent* slot); bool addOutputVariable(SlaveAgentSlotOfAgent* slot); bool setSlidingWindowBufferSize(unsigned int slidingWindowBufferSize); bool setMinNumOfRelatedValuesToBeStable(unsigned int minNumOfRelatedValuesToBeStable); bool setThresholdToBeStable(float thresholdToBeStable); bool setThresholdToBeRelated(float thresholdToBeRelated); void trigger(unsigned int cycle); //XXX - only for now void closeCsvFile(); void set_CSV_Writer_parameter(string cfg_parameter); void reset_States(); void reset_States_and_Slave_Agents(); + void setMaxStateHistoryLength(unsigned int maxStateHistoryLength); + ~StateHandler(); /* private: vector vSlots; unsigned int minNumOfChangedForValidStateChange; unsigned int minimumInjectionsForBeingState; void initStateHandler(); public: StateHandler(); StateHandler(char* name); bool setMinimumInjectionsForBeingState(unsigned int minimumInjectionsForBeingState); unsigned int getMinimumInjectionsForBeingState(); //TODO: function for deleting slot and function with the whole vector as parameter bool add_slot(SlaveAgentSlotOfAgent* slot); void set_minNumOfChangedForValidStateChange(unsigned int minNumOfChangedForValidStateChange); unsigned int get_minNumOfChangedForValidStateChange(); bool trigger(); */ }; #endif diff --git a/Version_Max_07_05_2018_CMake/src/StateVariable.h b/Version_Max_07_05_2018_CMake/src/StateVariable.h index 31e3413..2c1386b 100755 --- a/Version_Max_07_05_2018_CMake/src/StateVariable.h +++ b/Version_Max_07_05_2018_CMake/src/StateVariable.h @@ -1,19 +1,19 @@ #ifndef STATEVARIABLE_HEADERFILE #define STATEVARIABLE_HEADERFILE #include "SlaveAgentSlotOfAgent.h" class StateVariable { private: //TODO: for all slots ... generalize slot (not SlavAgent and Sensor) - SlaveAgentSlotOfAgent* slot; + //SlaveAgentSlotOfAgent* slot; public: StateVariable(); }; #endif \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/Testbench.cpp b/Version_Max_07_05_2018_CMake/src/Testbench.cpp index 90a7c3e..241488e 100755 --- a/Version_Max_07_05_2018_CMake/src/Testbench.cpp +++ b/Version_Max_07_05_2018_CMake/src/Testbench.cpp @@ -1,1026 +1,1026 @@ #include "Testbench.h" #include "printError.h" #include using namespace std; void Testbench :: init_testbench() { //TODO //some init source code to add, if necessary } Testbench :: Testbench() { set_name(NO_NAME); } -Testbench :: Testbench(char* name) { +Testbench :: Testbench(std::string name) { set_name(name); } bool Testbench :: register_agent(Agent* agent) { AgentSlotOfTestbench* agentSlot = new AgentSlotOfTestbench(); if(agentSlot != NULL) { if(agentSlot->set_agent(agent)) { try { if(vector_registeredAgents.size() < MAXNUM_OF_REGISTERED_AGENTS) { vector_registeredAgents.push_back(agentSlot); } else { printError("Max number of registered agents is already reached!"); return false; } } catch(bad_alloc& error) { printError("bad_alloc caught: ", error.what()); return false; } return true; } else { printError("Agent is not set!"); vector_registeredAgents.pop_back(); //TODO: check if it is right?!?! return false; } } else { printError("Couldn't create AgentSlot!"); return false; } } bool Testbench :: register_sensor(Sensor* sensor) { SensorSlotOfTestbench* sensorSlot = new SensorSlotOfTestbench(); if(sensorSlot != NULL) { if(sensorSlot->set_sensor(sensor)) { try { if(vector_registeredSensors.size() < MAXNUM_OF_REGISTERED_SENSORS) { vector_registeredSensors.push_back(sensorSlot); } else { printError("Max number of registered sensors is already reached!"); return false; } } catch(bad_alloc& error) { printError("bad_alloc caught: ", error.what()); return false; } return true; } else { printError("Input port is no set!"); vector_registeredSensors.pop_back(); //TODO: check if it is right?!?! return false; } } else { printError("Couldn't create SensorSlot!"); return false; } } SensorSlotOfTestbench* Testbench :: get_sensorSlotAddressOfTestbench(Sensor* sensor) { for(auto &sensorSlot : vector_registeredSensors) { if(sensorSlot->get_sensor() == sensor) { return sensorSlot; } } return NULL; } bool Testbench :: register_channel(Channel* channel) { ChannelSlotOfTestbench* channelSlot = new ChannelSlotOfTestbench(); if(channelSlot != NULL) { if(channelSlot->set_channel(channel)) { try { if(vector_registeredChannels.size() < MAXNUM_OF_REGISTERED_CHANNELS) { vector_registeredChannels.push_back(channelSlot); } else { printError("Max number of registered channels is already reached!"); return false; } } catch(bad_alloc& error) { printError("bad_alloc caught: ", error.what()); return false; } return true; } else { printError("Channel is not set!"); vector_registeredChannels.pop_back(); //TODO: check if it is right?!?! return false; } } else { printError("Couldn't create ChannelSlot!"); return false; } } bool Testbench :: register_testbench_config(Testbench_Config* tb_config) { vector_registered_Configs.push_back(tb_config); return true; //added by Ali, it is an error in VS. } vector& Testbench :: get_all_registered_testbench_configs() { return vector_registered_Configs; } void Testbench :: simulate(unsigned int rounds) { for(unsigned int cycle = 1; cycle <=rounds; cycle++) { if (cycle == 312) { printf("DEBUG: Break point"); } //printf("cycle %u\n", sec); //update sensor values for(auto &sensorSlot : vector_registeredSensors) { Sensor *sensor = sensorSlot->get_sensor(); - printf("Name of Sensor %s \n", sensor->get_name()); + //printf("Name of Sensor %s \n", sensor->get_name().c_str()); if(sensor != NULL) { CSVreaderModule *csvReader = sensorSlot->get_csvReaderModule(); if(csvReader != NULL) { float inputValue; if(csvReader->get_next_value(&inputValue)) { sensor->set_sensorValue(inputValue); } } } } //trigger sensors for(auto &sensorSlot : vector_registeredSensors) { Sensor *sensor = sensorSlot->get_sensor(); if(sensor != NULL) { sensor->trigger(); } } //trigger channels for(auto &channelSlot : vector_registeredChannels) { Channel *channel = channelSlot->get_channel(); if(channel != NULL) { channel->trigger(); } } //trigger agents for(auto &agentSlot : vector_registeredAgents) { Agent *agent = agentSlot->get_agent(); if(agent != NULL) { agent->trigger(cycle); } } //if(sec % 500 == 0) //getchar(); } //XXX - only for now for (auto &agentSlot : vector_registeredAgents) { Agent *agent = agentSlot->get_agent(); if (agent != NULL) { StateHandler *stateHandler = agent->get_stateHandler2(); if (stateHandler != NULL) { stateHandler->closeCsvFile(); } } } } vector& Testbench :: get_all_registeredAgents() { return vector_registeredAgents; } void Testbench :: set_current_tb_config_index(const int index) { Testbench_Config::set_active_Config(index); } void Testbench :: remove_all_Testbench_Configs() { unsigned int index_tb_conf = 0; unsigned int size_vec_tb_conf = vector_registered_Configs.size(); for(index_tb_conf = 0; index_tb_conf < size_vec_tb_conf; index_tb_conf++) { Testbench_Config* cur_config = vector_registered_Configs[index_tb_conf]; delete cur_config; } vector_registered_Configs.clear(); } void Testbench :: remove_all_Agents() { AgentSlotOfTestbench* cur_AgentSlot; unsigned int index_ag; unsigned int size_vec_reg_ag = vector_registeredAgents.size(); for(index_ag = 0; index_ag < size_vec_reg_ag; index_ag++) { cur_AgentSlot = vector_registeredAgents[index_ag]; delete cur_AgentSlot; } vector_registeredAgents.clear(); } void Testbench :: remove_all_Channels() { unsigned int index_ch; unsigned int size_vec_reg_chan = vector_registeredChannels.size(); for(index_ch = 0; index_ch < size_vec_reg_chan; index_ch++) { ChannelSlotOfTestbench* cur_ChaSlot = vector_registeredChannels[index_ch]; delete cur_ChaSlot; } vector_registeredChannels.clear(); } void Testbench :: remove_all_Sensors() { unsigned int index_sen; unsigned int size_vec_reg_sens = vector_registeredSensors.size(); for(index_sen = 0; index_sen < size_vec_reg_sens; index_sen++) { SensorSlotOfTestbench* cur_SenSlot = vector_registeredSensors[index_sen]; delete cur_SenSlot; } vector_registeredSensors.clear(); } bool Testbench :: free_resources() { AgentSlotOfTestbench* cur_Ag_Sl_Tb; unsigned int index_reg_Agents; unsigned int size_vec_reg_Agents = vector_registeredAgents.size(); for(index_reg_Agents = 0; index_reg_Agents < size_vec_reg_Agents; index_reg_Agents++) { cur_Ag_Sl_Tb = vector_registeredAgents[index_reg_Agents]; - Agent* cur_Ag = cur_Ag_Sl_Tb->get_agent(); + //Agent* cur_Ag = cur_Ag_Sl_Tb->get_agent(); //cur_Ag->del_stateHandler(); } return true; //added by Ali, it is an error in VS. } void Testbench::set_CSV_Writer_parameter() { unsigned int size_of_vec_reg_Agents = vector_registeredAgents.size(); AgentSlotOfTestbench* viability_slot_Agent = vector_registeredAgents[size_of_vec_reg_Agents - 1]; Agent* viability_Agent = viability_slot_Agent->get_agent(); StateHandler* cur_state_Handl = viability_Agent->get_stateHandler(); Testbench_Config* cur_tb_cfg; string tb_cfg; cur_tb_cfg = get_current_Testbench_config(); if(cur_tb_cfg != NULL) { tb_cfg = cur_tb_cfg->get_Config_as_String(); cur_state_Handl->set_CSV_Writer_parameter(tb_cfg); } } Testbench_Config* Testbench :: get_current_Testbench_config() { unsigned int index_cur_tb_cfg = 0; unsigned int size_tb_cfg = vector_registered_Configs.size(); Testbench_Config* cur_tb_cfg; for(index_cur_tb_cfg = 0; index_cur_tb_cfg < size_tb_cfg; index_cur_tb_cfg++){ cur_tb_cfg = vector_registered_Configs[index_cur_tb_cfg]; if(cur_tb_cfg->get_own_index() == Testbench_Config::get_active_Config()){ return cur_tb_cfg; } } return NULL; } void Testbench :: set_config_values_in_linear_functions() { - unsigned int index_reg_Agents = 0; + //unsigned int index_reg_Agents = 0; unsigned int size_of_vec_reg_Agents; vector vec_reg_Agents = this->get_all_registeredAgents(); size_of_vec_reg_Agents = vec_reg_Agents.size(); AgentSlotOfTestbench* viability_slot_Agent = vec_reg_Agents[vec_reg_Agents.size()-1]; Agent* viability_Agent = viability_slot_Agent->get_agent(); StateHandler* cur_state_Handl = viability_Agent->get_stateHandler(); set_parameters_FuncBlockConfSim2StateDev(cur_state_Handl->FuncBlockConfSim2StateDev); set_parameters_FuncBlockConfDif2StateDev(cur_state_Handl->FuncBlockConfDif2StateDev); set_parameters_FuncBlockConfSim2StateTime(cur_state_Handl->FuncBlockConfSim2StateTime); set_parameters_FuncBlockConfDif2StateTime(cur_state_Handl->FuncBlockConfDif2StateTime); set_parameters_FuncBlockConfValStateDev(cur_state_Handl->FuncBlockConfValStateDev); set_parameters_FuncBlockConfInvStateDev(cur_state_Handl->FuncBlockConfInvStateDev); set_parameters_FuncBlockConfValStateTime(cur_state_Handl->FuncBlockConfValStateTime); set_parameters_FuncBlockConfInvStateTime(cur_state_Handl->FuncBlockConfInvStateTime); set_parameters_DriftDeviation(cur_state_Handl->DriftDeviation); set_parameters_FuncBlockConfBrokenSamples(cur_state_Handl->FuncBlockConfBrokenSamples); } void Testbench :: set_parameters_FuncBlockConfSim2StateDev(LinearFunctionBlock* FuncBlockConfSim2StateDev) { LinearFunction* cur_Lin_Fun; vector vec_Lin_Fun = FuncBlockConfSim2StateDev->get_all_LinearFunctions(); unsigned int size_vec_Lin_Fun = vec_Lin_Fun.size(); unsigned int index_cur_Lin_Fun = 0; Testbench_Config* cur_Tb_cfg = this->get_current_Testbench_config(); for(index_cur_Lin_Fun = 0; index_cur_Lin_Fun < size_vec_Lin_Fun; index_cur_Lin_Fun++) { One_Config_t cur_values = cur_Tb_cfg->get_Config(); cur_Lin_Fun = vec_Lin_Fun[index_cur_Lin_Fun]; if(cur_Lin_Fun->getName() == CONF_SIM2_STATE_DEV_1) { cur_Lin_Fun->setDomain(false, true, (float)-cur_values.outter_bound_sim_dif); cur_Lin_Fun->setKandD((float)0, (float)0); }else if (cur_Lin_Fun->getName() == CONF_SIM2_STATE_DEV_2) { cur_Lin_Fun->setDomain(true, (float)-cur_values.outter_bound_sim_dif, true, (float)-cur_values.inner_bound_sim_dif); cur_Lin_Fun->setKandD((float)-cur_values.outter_bound_sim_dif, (float)0, (float)-cur_values.inner_bound_sim_dif, (float)1); }else if (cur_Lin_Fun->getName() == CONF_SIM2_STATE_DEV_3) { cur_Lin_Fun->setDomain(true, (float)-cur_values.inner_bound_sim_dif, true, (float)cur_values.inner_bound_sim_dif); cur_Lin_Fun->setKandD((float)0, (float)1); }else if(cur_Lin_Fun->getName() == CONF_SIM2_STATE_DEV_4){ cur_Lin_Fun->setDomain(true, (float)cur_values.inner_bound_sim_dif, true, (float)cur_values.outter_bound_sim_dif); cur_Lin_Fun->setKandD((float)cur_values.inner_bound_sim_dif, (float)1, (float)cur_values.outter_bound_sim_dif, (float)0); }else if(cur_Lin_Fun->getName() == CONF_SIM2_STATE_DEV_5){ cur_Lin_Fun->setDomain(true, (float)cur_values.outter_bound_sim_dif, false); cur_Lin_Fun->setKandD((float)0, (float)0); } } } void Testbench :: set_parameters_FuncBlockConfDif2StateDev(LinearFunctionBlock* FuncBlockConfDif2StateDev) { LinearFunction* cur_Lin_Fun; vector vec_Lin_Fun = FuncBlockConfDif2StateDev->get_all_LinearFunctions(); unsigned int size_vec_Lin_Fun = vec_Lin_Fun.size(); unsigned int index_cur_Lin_Fun = 0; Testbench_Config* cur_Tb_cfg = this->get_current_Testbench_config(); for(index_cur_Lin_Fun = 0; index_cur_Lin_Fun < size_vec_Lin_Fun; index_cur_Lin_Fun++) { One_Config_t cur_values = cur_Tb_cfg->get_Config(); cur_Lin_Fun = vec_Lin_Fun[index_cur_Lin_Fun]; if(cur_Lin_Fun->getName() == CONF_DIF2_STATE_DEV_1) { cur_Lin_Fun->setDomain(false, true, (float)-cur_values.outter_bound_sim_dif); cur_Lin_Fun->setKandD((float)0, (float)1); }else if (cur_Lin_Fun->getName() == CONF_DIF2_STATE_DEV_2) { cur_Lin_Fun->setDomain(true, (float)-cur_values.outter_bound_sim_dif, true, (float)-cur_values.inner_bound_sim_dif); cur_Lin_Fun->setKandD((float)-cur_values.outter_bound_sim_dif, (float)1, (float)-cur_values.inner_bound_sim_dif, (float)0); }else if (cur_Lin_Fun->getName() == CONF_DIF2_STATE_DEV_3) { cur_Lin_Fun->setDomain(true, (float)-cur_values.inner_bound_sim_dif, true, (float)cur_values.inner_bound_sim_dif); cur_Lin_Fun->setKandD((float)0, (float)0); }else if(cur_Lin_Fun->getName() == CONF_DIF2_STATE_DEV_4){ cur_Lin_Fun->setDomain(true, (float)cur_values.inner_bound_sim_dif, true, (float)cur_values.outter_bound_sim_dif); cur_Lin_Fun->setKandD((float)cur_values.inner_bound_sim_dif, (float)0, (float)cur_values.outter_bound_sim_dif, (float)1); }else if(cur_Lin_Fun->getName() == CONF_DIF2_STATE_DEV_5){ cur_Lin_Fun->setDomain(true, (float)cur_values.outter_bound_sim_dif, false); cur_Lin_Fun->setKandD((float)0, (float)1); } } } void Testbench :: set_parameters_FuncBlockConfSim2StateTime(LinearFunctionBlock* FuncBlockConfSim2StateTime) { LinearFunction* cur_Lin_Fun; vector vec_Lin_Fun = FuncBlockConfSim2StateTime->get_all_LinearFunctions(); unsigned int size_vec_Lin_Fun = vec_Lin_Fun.size(); unsigned int index_cur_Lin_Fun = 0; Testbench_Config* cur_Tb_cfg = this->get_current_Testbench_config(); for(index_cur_Lin_Fun = 0; index_cur_Lin_Fun < size_vec_Lin_Fun; index_cur_Lin_Fun++) { One_Config_t cur_values = cur_Tb_cfg->get_Config(); cur_Lin_Fun = vec_Lin_Fun[index_cur_Lin_Fun]; if(cur_Lin_Fun->getName() == CONF_SIM2_STATE_TIME_1) { cur_Lin_Fun->setDomain(false, true, (float)0); cur_Lin_Fun->setKandD((float)0, (float)0); }else if (cur_Lin_Fun->getName() == CONF_SIM2_STATE_TIME_2) { cur_Lin_Fun->setDomain(true, (float)0, true, (float)cur_values.length); cur_Lin_Fun->setKandD((float)0, (float)0, (float)cur_values.length, (float)1); }else if (cur_Lin_Fun->getName() == CONF_SIM2_STATE_TIME_3) { cur_Lin_Fun->setDomain(true, (float)cur_values.length, false); cur_Lin_Fun->setKandD((float)0, (float)1); } } } void Testbench :: set_parameters_FuncBlockConfDif2StateTime(LinearFunctionBlock* FuncBlockConfDif2StateTime) { LinearFunction* cur_Lin_Fun; vector vec_Lin_Fun = FuncBlockConfDif2StateTime->get_all_LinearFunctions(); unsigned int size_vec_Lin_Fun = vec_Lin_Fun.size(); unsigned int index_cur_Lin_Fun = 0; Testbench_Config* cur_Tb_cfg = this->get_current_Testbench_config(); for(index_cur_Lin_Fun = 0; index_cur_Lin_Fun < size_vec_Lin_Fun; index_cur_Lin_Fun++) { One_Config_t cur_values = cur_Tb_cfg->get_Config(); cur_Lin_Fun = vec_Lin_Fun[index_cur_Lin_Fun]; if(cur_Lin_Fun->getName() == CONF_DIF2_STATE_TIME_1) { cur_Lin_Fun->setDomain(false, true, (float)0); cur_Lin_Fun->setKandD((float)0, (float)1); }else if (cur_Lin_Fun->getName() == CONF_DIF2_STATE_TIME_2) { cur_Lin_Fun->setDomain(true, (float)0, true, (float)cur_values.length); cur_Lin_Fun->setKandD((float)0, (float)1, (float)cur_values.length, (float)0); }else if (cur_Lin_Fun->getName() == CONF_DIF2_STATE_TIME_3) { cur_Lin_Fun->setDomain(true, (float)cur_values.length, false); cur_Lin_Fun->setKandD((float)0, (float)0); } } } void Testbench :: set_parameters_FuncBlockConfValStateDev(LinearFunctionBlock* FuncBlockConfValStateDev) { LinearFunction* cur_Lin_Fun; vector vec_Lin_Fun = FuncBlockConfValStateDev->get_all_LinearFunctions(); unsigned int size_vec_Lin_Fun = vec_Lin_Fun.size(); unsigned int index_cur_Lin_Fun = 0; Testbench_Config* cur_Tb_cfg = this->get_current_Testbench_config(); for(index_cur_Lin_Fun = 0; index_cur_Lin_Fun < size_vec_Lin_Fun; index_cur_Lin_Fun++) { One_Config_t cur_values = cur_Tb_cfg->get_Config(); cur_Lin_Fun = vec_Lin_Fun[index_cur_Lin_Fun]; if(cur_Lin_Fun->getName() == CONF_VALID_STATE_DEV_1) { cur_Lin_Fun->setDomain(false, true, (float)-cur_values.outter_bound_sim_dif); cur_Lin_Fun->setKandD((float)0, (float)0); }else if (cur_Lin_Fun->getName() == CONF_VALID_STATE_DEV_2) { cur_Lin_Fun->setDomain(true, (float)-cur_values.outter_bound_sim_dif, true, (float)-cur_values.inner_bound_sim_dif); cur_Lin_Fun->setKandD((float)-cur_values.outter_bound_sim_dif, (float)0, (float)-cur_values.inner_bound_sim_dif, (float)1); }else if (cur_Lin_Fun->getName() == CONF_VALID_STATE_DEV_3) { cur_Lin_Fun->setDomain(true, (float)-cur_values.inner_bound_sim_dif, true, (float)cur_values.inner_bound_sim_dif); cur_Lin_Fun->setKandD((float)0, (float)1); }else if(cur_Lin_Fun->getName() == CONF_VALID_STATE_DEV_4){ cur_Lin_Fun->setDomain(true, (float)cur_values.inner_bound_sim_dif, true, (float)cur_values.outter_bound_sim_dif); cur_Lin_Fun->setKandD((float)cur_values.inner_bound_sim_dif, (float)1, (float)cur_values.outter_bound_sim_dif, (float)0); }else if(cur_Lin_Fun->getName() == CONF_VALID_STATE_DEV_5){ cur_Lin_Fun->setDomain(true, (float)cur_values.outter_bound_sim_dif, false); cur_Lin_Fun->setKandD((float)0, (float)0); } } } void Testbench :: set_parameters_FuncBlockConfInvStateDev(LinearFunctionBlock* FuncBlockConfInvStateDev) { LinearFunction* cur_Lin_Fun; vector vec_Lin_Fun = FuncBlockConfInvStateDev->get_all_LinearFunctions(); unsigned int size_vec_Lin_Fun = vec_Lin_Fun.size(); unsigned int index_cur_Lin_Fun = 0; Testbench_Config* cur_Tb_cfg = this->get_current_Testbench_config(); for(index_cur_Lin_Fun = 0; index_cur_Lin_Fun < size_vec_Lin_Fun; index_cur_Lin_Fun++) { One_Config_t cur_values = cur_Tb_cfg->get_Config(); cur_Lin_Fun = vec_Lin_Fun[index_cur_Lin_Fun]; if(cur_Lin_Fun->getName() == CONF_INVALID_STATE_DEV_1) { cur_Lin_Fun->setDomain(false, true, (float)-cur_values.outter_bound_sim_dif); cur_Lin_Fun->setKandD((float)0, (float)1); }else if (cur_Lin_Fun->getName() == CONF_INVALID_STATE_DEV_2) { cur_Lin_Fun->setDomain(true, (float)-cur_values.outter_bound_sim_dif, true, (float)-cur_values.inner_bound_sim_dif); cur_Lin_Fun->setKandD((float)-cur_values.outter_bound_sim_dif, (float)1, (float)-cur_values.inner_bound_sim_dif, (float)0); }else if (cur_Lin_Fun->getName() == CONF_INVALID_STATE_DEV_3) { cur_Lin_Fun->setDomain(true, (float)-cur_values.inner_bound_sim_dif, true, (float)cur_values.inner_bound_sim_dif); cur_Lin_Fun->setKandD((float)0, (float)0); }else if(cur_Lin_Fun->getName() == CONF_INVALID_STATE_DEV_4){ cur_Lin_Fun->setDomain(true, (float)cur_values.inner_bound_sim_dif, true, (float)cur_values.outter_bound_sim_dif); cur_Lin_Fun->setKandD((float)cur_values.inner_bound_sim_dif, (float)0, (float)cur_values.outter_bound_sim_dif, (float)1); }else if(cur_Lin_Fun->getName() == CONF_INVALID_STATE_DEV_5){ cur_Lin_Fun->setDomain(true, (float)cur_values.outter_bound_sim_dif, false); cur_Lin_Fun->setKandD((float)0, (float)1); } } } void Testbench :: set_parameters_FuncBlockConfValStateTime(LinearFunctionBlock* FuncBlockConfValStateTime) { LinearFunction* cur_Lin_Fun; vector vec_Lin_Fun = FuncBlockConfValStateTime->get_all_LinearFunctions(); unsigned int size_vec_Lin_Fun = vec_Lin_Fun.size(); unsigned int index_cur_Lin_Fun = 0; Testbench_Config* cur_Tb_cfg = this->get_current_Testbench_config(); for(index_cur_Lin_Fun = 0; index_cur_Lin_Fun < size_vec_Lin_Fun; index_cur_Lin_Fun++) { One_Config_t cur_values = cur_Tb_cfg->get_Config(); cur_Lin_Fun = vec_Lin_Fun[index_cur_Lin_Fun]; if(cur_Lin_Fun->getName() == VALID_STATE_TIME_1) { cur_Lin_Fun->setDomain(false, true, (float)0); cur_Lin_Fun->setKandD((float)0, (float)0); }else if (cur_Lin_Fun->getName() == VALID_STATE_TIME_2) { cur_Lin_Fun->setDomain(true, (float)0, true, (float)cur_values.length); cur_Lin_Fun->setKandD((float)0, (float)0, (float)cur_values.length, (float)1); }else if (cur_Lin_Fun->getName() == VALID_STATE_TIME_3) { cur_Lin_Fun->setDomain(true, (float)cur_values.length, false); cur_Lin_Fun->setKandD((float)0, (float)1); } } } void Testbench :: set_parameters_FuncBlockConfInvStateTime(LinearFunctionBlock* FuncBlockConfInvStateTime) { LinearFunction* cur_Lin_Fun; vector vec_Lin_Fun = FuncBlockConfInvStateTime->get_all_LinearFunctions(); unsigned int size_vec_Lin_Fun = vec_Lin_Fun.size(); unsigned int index_cur_Lin_Fun = 0; Testbench_Config* cur_Tb_cfg = this->get_current_Testbench_config(); for(index_cur_Lin_Fun = 0; index_cur_Lin_Fun < size_vec_Lin_Fun; index_cur_Lin_Fun++) { One_Config_t cur_values = cur_Tb_cfg->get_Config(); cur_Lin_Fun = vec_Lin_Fun[index_cur_Lin_Fun]; if(cur_Lin_Fun->getName() == INVALID_STATE_TIME_1) { cur_Lin_Fun->setDomain(false, true, (float)0); cur_Lin_Fun->setKandD((float)0, (float)1); }else if (cur_Lin_Fun->getName() == INVALID_STATE_TIME_2) { cur_Lin_Fun->setDomain(true, (float)0, true, (float)cur_values.length); cur_Lin_Fun->setKandD((float)0, (float)1, (float)cur_values.length, (float)0); }else if (cur_Lin_Fun->getName() == INVALID_STATE_TIME_3) { cur_Lin_Fun->setDomain(true, (float)cur_values.length, false); cur_Lin_Fun->setKandD((float)0, (float)0); } } } void Testbench :: set_parameters_DriftDeviation(LinearFunctionBlock* DriftDeviation) { LinearFunction* cur_Lin_Fun; vector vec_Lin_Fun = DriftDeviation->get_all_LinearFunctions(); unsigned int size_vec_Lin_Fun = vec_Lin_Fun.size(); unsigned int index_cur_Lin_Fun = 0; Testbench_Config* cur_Tb_cfg = this->get_current_Testbench_config(); for(index_cur_Lin_Fun = 0; index_cur_Lin_Fun < size_vec_Lin_Fun; index_cur_Lin_Fun++) { One_Config_t cur_values = cur_Tb_cfg->get_Config(); cur_Lin_Fun = vec_Lin_Fun[index_cur_Lin_Fun]; if(cur_Lin_Fun->getName() == CONFIDENCE_DRIFT_DEVIATION_1) { cur_Lin_Fun->setDomain(false, true, (float)-cur_values.outter_bound_drift); cur_Lin_Fun->setKandD((float)0, (float)1); }else if (cur_Lin_Fun->getName() == CONFIDENCE_DRIFT_DEVIATION_2) { cur_Lin_Fun->setDomain(true, (float)-cur_values.outter_bound_drift, true, (float)-cur_values.inner_bound_drift); cur_Lin_Fun->setKandD((float)-cur_values.inner_bound_drift, (float)1, (float)-cur_values.inner_bound_drift, (float)0); }else if (cur_Lin_Fun->getName() == CONFIDENCE_DRIFT_DEVIATION_3) { //this line causes a small deviation between the old solution with define and the new one //I didn't figure out how to get an totally equal result. cur_Lin_Fun->setDomain(true,(float) -cur_values.inner_bound_drift, true,(float) cur_values.inner_bound_drift); cur_Lin_Fun->setKandD((float)0, (float)0); }else if(cur_Lin_Fun->getName() == CONFIDENCE_DRIFT_DEVIATION_4){ cur_Lin_Fun->setDomain(true, (float)cur_values.inner_bound_drift, true, (float)cur_values.outter_bound_drift); cur_Lin_Fun->setKandD((float)cur_values.inner_bound_drift, (float)0, (float)cur_values.outter_bound_drift, (float)1); }else if(cur_Lin_Fun->getName() == CONFIDENCE_DRIFT_DEVIATION_5){ cur_Lin_Fun->setDomain(true, (float)cur_values.outter_bound_drift, false); cur_Lin_Fun->setKandD((float)0, (float)1); } } } void Testbench :: set_parameters_FuncBlockConfBrokenSamples(LinearFunctionBlock* FuncBlockConfBrokenSamples) { LinearFunction* cur_Lin_Fun; vector vec_Lin_Fun = FuncBlockConfBrokenSamples->get_all_LinearFunctions(); unsigned int size_vec_Lin_Fun = vec_Lin_Fun.size(); unsigned int index_cur_Lin_Fun = 0; Testbench_Config* cur_Tb_cfg = this->get_current_Testbench_config(); for(index_cur_Lin_Fun = 0; index_cur_Lin_Fun < size_vec_Lin_Fun; index_cur_Lin_Fun++) { One_Config_t cur_values = cur_Tb_cfg->get_Config(); cur_Lin_Fun = vec_Lin_Fun[index_cur_Lin_Fun]; if(cur_Lin_Fun->getName() == CONFIDENCE_BROKEN_1) { cur_Lin_Fun->setDomain(false, true, (float)0); cur_Lin_Fun->setKandD((float)0, (float)0); }else if (cur_Lin_Fun->getName() == CONFIDENCE_BROKEN_2) { cur_Lin_Fun->setDomain(true, (float)0, true, (float)cur_values.bound_broken); cur_Lin_Fun->setKandD((float)0, (float)0, (float)cur_values.bound_broken, (float)1); }else if (cur_Lin_Fun->getName() == CONFIDENCE_BROKEN_3) { cur_Lin_Fun->setDomain(true, (float)cur_values.bound_broken, false); cur_Lin_Fun->setKandD((float)0, (float)1); } } } void Testbench :: set_CSV_Reader_row(const int start_row) { unsigned int size_of_vec_reg_Sens = vector_registeredSensors.size(); SensorSlotOfTestbench* cur_sens_Slot; unsigned int index_cur_Slot = 0; CSVreaderModule* assigned_CSVReader; for(index_cur_Slot = 0; index_cur_Slot < size_of_vec_reg_Sens; index_cur_Slot++){ cur_sens_Slot = vector_registeredSensors[index_cur_Slot]; assigned_CSVReader = cur_sens_Slot->get_csvReaderModule(); assigned_CSVReader->reset_row(start_row); } } void Testbench :: set_CSV_Reader_to_beginning() { unsigned int size_of_vec_reg_Sens = vector_registeredSensors.size(); SensorSlotOfTestbench* cur_sens_Slot; unsigned int index_cur_Slot = 0; CSVreaderModule* assigned_CSVReader; - unsigned const int START_ROW = 1; + //unsigned const int START_ROW = 1; for(index_cur_Slot = 0; index_cur_Slot < size_of_vec_reg_Sens; index_cur_Slot++){ cur_sens_Slot = vector_registeredSensors[index_cur_Slot]; assigned_CSVReader = cur_sens_Slot->get_csvReaderModule(); assigned_CSVReader->set_position_fpointer_to_start(); } } void Testbench:: reset_States() { unsigned int size_of_vec_reg_Agents = vector_registeredAgents.size(); AgentSlotOfTestbench* viability_slot_Agent = vector_registeredAgents[size_of_vec_reg_Agents - 1]; Agent* viability_Agent = viability_slot_Agent->get_agent(); StateHandler* cur_state_Handl = viability_Agent->get_stateHandler(); cur_state_Handl->reset_States(); } void Testbench:: reset_States_and_Slave_Agents() { unsigned int size_of_vec_reg_Agents = vector_registeredAgents.size(); AgentSlotOfTestbench* viability_slot_Agent = vector_registeredAgents[size_of_vec_reg_Agents - 1]; Agent* viability_Agent = viability_slot_Agent->get_agent(); StateHandler* cur_state_Handl = viability_Agent->get_stateHandler(); cur_state_Handl->reset_States_and_Slave_Agents(); } Testbench :: ~Testbench() { remove_all_Testbench_Configs(); remove_all_Agents(); remove_all_Channels(); remove_all_Sensors(); } /* Testbench :: Testbench() { num_of_registered_agents = 0; num_of_registered_sensors = 0; num_of_registered_channels = 0; this->id = num_of_units; num_of_units++; this->set_name(NO_NAME); //csv flag_csv_reader_exist = false; flag_csv_writer_exist = false; } Testbench :: Testbench(char* name) { num_of_registered_agents = 0; num_of_registered_sensors = 0; num_of_registered_channels = 0; this->id = num_of_units; num_of_units++; this->set_name(name); //csv flag_csv_reader_exist = false; flag_csv_writer_exist = false; } void Testbench :: simulate() { if(flag_csv_writer_exist) { csv_writer->write_field("second"); csv_writer->make_new_field(); for(unsigned int s_ix=0; s_ixwrite_field(registered_sensors[s_ix]->get_name()); csv_writer->make_new_field(); } for(unsigned int a_ix=0; a_ixwrite_field(registered_agents[a_ix]->get_name()); csv_writer->make_new_field(); } csv_writer->write_field("confidence counter"); csv_writer->make_new_field(); csv_writer->make_new_line(); } //TODO: HIER ENDLOSSCHLEIFE ODER SO - Irgendwas, dass stoppt, wenn file zu ende for(unsigned int sec=1; sec<=29208; sec++) { printf("second %u\n", sec); if(flag_csv_writer_exist) { csv_writer->write_field((int)sec); csv_writer->make_new_field(); } //Update Sensor Values for(unsigned int s_ix = 0; s_ix < num_of_registered_sensors; s_ix++) { //TODO: make possibility of non-registered csv-reader if(flag_sensor_has_csvr[s_ix]) { float value_from_csv; if(registered_sensors_csvr[s_ix] != NULL) { if(registered_sensors_csvr[s_ix]->get_next_value(&value_from_csv)) { registered_sensors[s_ix]->update_sensor_value(value_from_csv); //printf("field of %s: %f", registered_sensors[s_ix]->get_name(), value_from_csv); } } } } for(unsigned int s_ix = 0; s_ix < num_of_registered_sensors; s_ix++) { registered_sensors[s_ix]->trigger(); if(flag_csv_writer_exist) { if(registered_sensors[s_ix]->get_flag_sensor_value_is_valid()) { csv_writer->write_field(registered_sensors[s_ix]->get_sensor_value()); } csv_writer->make_new_field(); } } for(unsigned int c_ix = 0; c_ix < num_of_registered_channels; c_ix++) { //printf("\n\n\nTRIGGER CHANNELS\n"); registered_channels[c_ix]->trigger(); } for(unsigned int a_ix = 0; a_ix < num_of_registered_agents; a_ix++) { registered_agents[a_ix]->trigger(); if(flag_csv_writer_exist) { if(registered_agents[a_ix]->get_flag_bunched_score_exist()) { csv_writer->write_field(registered_agents[a_ix]->get_bunched_score()); csv_writer->make_new_field(); csv_writer->write_field((int)registered_agents[a_ix]->get_bunch_score_confidency()); } else if(registered_agents[a_ix]->get_flag_abstracted_sensor_score_exist(0)) { csv_writer->write_field(registered_agents[a_ix]->get_abstracted_sensor_score(0)); } if(a_ix < num_of_registered_agents-1) { csv_writer->make_new_field(); } } } if(flag_csv_writer_exist) { csv_writer->make_new_line(); } getchar(); } if(flag_csv_writer_exist) { csv_writer->close_file(); } } //for agents: unsigned int Testbench :: get_num_of_registered_agents() { return num_of_registered_agents; } bool Testbench :: register_agent(Agent *agent) { if(num_of_registered_agents < MAX_NUM_OF_AGENTS) { registered_agents[num_of_registered_agents] = agent; num_of_registered_agents++; return true; } return false; } bool Testbench :: deregister_agent(Agent *agent) { unsigned int agent_ix; if(get_ix_of_agent(agent, &agent_ix)) { return deregister_agent(agent_ix); } return false; } bool Testbench :: deregister_agent(unsigned int agent_ix) { if(agent_ix < num_of_registered_agents) { for(unsigned int a_ix=agent_ix; a_ixcsv_reader = csv_reader; flag_csv_reader_exist = true; return true; } return false; } bool Testbench :: register_csv_writer(CSV_Writer* csv_writer) { if(csv_writer != NULL) { this->csv_writer = csv_writer; flag_csv_writer_exist = true; return true; } return false; } */ diff --git a/Version_Max_07_05_2018_CMake/src/Testbench.h b/Version_Max_07_05_2018_CMake/src/Testbench.h index d219b2e..7ad9dfc 100755 --- a/Version_Max_07_05_2018_CMake/src/Testbench.h +++ b/Version_Max_07_05_2018_CMake/src/Testbench.h @@ -1,219 +1,219 @@ #ifndef TESTBENCH_HEADERFILE #define TESTBENCH_HEADERFILE #include #include "AgentSlotOfTestbench.h" #include "ChannelSlotOfTestbench.h" #include "CSVreaderModule.h" #include "SensorSlotOfTestbench.h" #include "Unit.h" #include "Agent.h" #include "Testbench_Config.h" /* #include "Agent.h" #include "Channel.h" #include "CSVreader.h" #include "CSV_Writer.h" #define MAX_NUM_OF_AGENTS 20 #define MAX_NUM_OF_CHANNELS 80 #define MAX_NUM_OF_SENSORS 20 */ using namespace std; //definitions for the linear function blocks, with their associated linear function names //first name of the linear function block and then the names of the linear functions registered //within this function block, is later used to identify the right linear function //to parameterize it correctly. const string FUNC_BLOCK_NAME_SAME_STATE_DEV = "funcBlock:confSim2StateDev"; const string CONF_SIM2_STATE_DEV_1 = "ConfSim2StateDev1"; const string CONF_SIM2_STATE_DEV_2 = "ConfSim2StateDev2"; const string CONF_SIM2_STATE_DEV_3 = "ConfSim2StateDev3"; const string CONF_SIM2_STATE_DEV_4 = "ConfSim2StateDev4"; const string CONF_SIM2_STATE_DEV_5 = "ConfSim2StateDev5"; const string FUNC_BLOCK_NAME_ANOTHER_STATE_DEV = "funcBlock:confDif2StateDev"; const string CONF_DIF2_STATE_DEV_1 = "ConfDif2StateDev1"; const string CONF_DIF2_STATE_DEV_2 = "ConfDif2StateDev2"; const string CONF_DIF2_STATE_DEV_3 = "ConfDif2StateDev3"; const string CONF_DIF2_STATE_DEV_4 = "ConfDif2StateDev4"; const string CONF_DIF2_STATE_DEV_5 = "ConfDif2StateDev5"; const string FUNC_BLOCK_NAME_SAME_TIME = "funcBlock:confSim2StateTime"; const string CONF_SIM2_STATE_TIME_1 = "ConfSim2StateTime1"; const string CONF_SIM2_STATE_TIME_2 = "ConfSim2StateTime2"; const string CONF_SIM2_STATE_TIME_3 = "ConfSim2StateTime3"; const string FUNC_BLOCK_NAME_ANOTHER_STATE_TIME = "funcBlock:confDif2StateTime"; const string CONF_DIF2_STATE_TIME_1 = "ConfDif2StateTime1"; const string CONF_DIF2_STATE_TIME_2 = "ConfDif2StateTime2"; const string CONF_DIF2_STATE_TIME_3 = "ConfDif2StateTime3"; const string FUNC_BLOCK_NAME_VAILD_STATE_DEV = "funcBlock:confValidStateDev"; const string CONF_VALID_STATE_DEV_1 = "ConfValidStateDev1"; const string CONF_VALID_STATE_DEV_2 = "ConfValidStateDev2"; const string CONF_VALID_STATE_DEV_3 = "ConfValidStateDev3"; const string CONF_VALID_STATE_DEV_4 = "ConfValidStateDev4"; const string CONF_VALID_STATE_DEV_5 = "ConfValidStateDev5"; const string FUNC_BLOCK_NAME_INVALID_STATE_DEV = "funcBlock:confInvalidStateDev"; const string CONF_INVALID_STATE_DEV_1 = "ConfInvalidStateDev1"; const string CONF_INVALID_STATE_DEV_2 = "ConfInvalidStateDev2"; const string CONF_INVALID_STATE_DEV_3 = "ConfInvalidStateDev3"; const string CONF_INVALID_STATE_DEV_4 = "ConfInvalidStateDev4"; const string CONF_INVALID_STATE_DEV_5 = "ConfInvalidStateDev5"; const string FUNC_BLOCK_NAME_VALID_STATE_TIME = "funcBlock:confValidStateTime"; const string VALID_STATE_TIME_1 = "ValidStateTime1"; const string VALID_STATE_TIME_2 = "ValidStateTime2"; const string VALID_STATE_TIME_3 = "ValidStateTime3"; const string FUNC_BLOCK_NAME_INVALID_STATE_TIME = "funcBlock:confInvalidStateTime"; const string INVALID_STATE_TIME_1 = "InvalidStateTime1"; const string INVALID_STATE_TIME_2 = "InvalidStateTime2"; const string INVALID_STATE_TIME_3 = "InvalidStateTime3"; const string FUNC_BLOCK_NAME_CONFIDENCE_STATE_DRIFTS = "confidence:confStateDrifts"; const string CONFIDENCE_DRIFT_DEVIATION_1 = "ConfidenceDriftDeviation1"; const string CONFIDENCE_DRIFT_DEVIATION_2 = "ConfidenceDriftDeviation2"; const string CONFIDENCE_DRIFT_DEVIATION_3 = "ConfidenceDriftDeviation3"; const string CONFIDENCE_DRIFT_DEVIATION_4 = "ConfidenceDriftDeviation4"; const string CONFIDENCE_DRIFT_DEVIATION_5 = "ConfidenceDriftDeviation5"; const string FUNC_BLOCK_NAME_CONFIDENCE_BROKEN = "confidence:broken"; const string CONFIDENCE_BROKEN_1 = "ConfidenceBroken1"; const string CONFIDENCE_BROKEN_2 = "ConfidenceBroken2"; const string CONFIDENCE_BROKEN_3 = "ConfidenceBroken3"; class Testbench : public Module { private: //TODO: set- and get function for maxNumOf_registeredAgents; vector vector_registeredAgents; //TODO: set- and get function for maxNumOf_registeredChannels; vector vector_registeredChannels; //TODO: set- and get function for maxNumOf_registeredSensors; vector vector_registeredSensors; vector vector_registered_Configs; void remove_all_Testbench_Configs(); void remove_all_Agents(); void remove_all_Channels(); void remove_all_Sensors(); void set_parameters_FuncBlockConfSim2StateDev(LinearFunctionBlock* FuncBlockConfSim2StateDev); void set_parameters_FuncBlockConfDif2StateDev(LinearFunctionBlock* FuncBlockConfDif2StateDev); void set_parameters_FuncBlockConfSim2StateTime(LinearFunctionBlock* FuncBlockConfSim2StateTime); void set_parameters_FuncBlockConfDif2StateTime(LinearFunctionBlock* FuncBlockConfDif2StateTime); void set_parameters_FuncBlockConfValStateDev(LinearFunctionBlock* FuncBlockConfValStateDev); void set_parameters_FuncBlockConfInvStateDev(LinearFunctionBlock* FuncBlockConfInvStateDev); void set_parameters_FuncBlockConfValStateTime(LinearFunctionBlock* FuncBlockConfValStateTime); void set_parameters_FuncBlockConfInvStateTime(LinearFunctionBlock* FuncBlockConfInvStateTime); void set_parameters_DriftDeviation(LinearFunctionBlock* DriftDeviation); void set_parameters_FuncBlockConfBrokenSamples(LinearFunctionBlock* FuncBlockConfBrokenSamples); public: static const unsigned int MAXNUM_OF_REGISTERED_AGENTS = 1000; static const unsigned int MAXNUM_OF_REGISTERED_CHANNELS = 1000; static const unsigned int MAXNUM_OF_REGISTERED_SENSORS = 1000; Testbench(); - Testbench(char* name); + Testbench(std::string name); void init_testbench(); bool register_agent(Agent* agent); bool register_sensor(Sensor* sensor); SensorSlotOfTestbench* get_sensorSlotAddressOfTestbench(Sensor* sensor); bool register_channel(Channel* channel); bool register_testbench_config(Testbench_Config* tb_config); vector& get_all_registered_testbench_configs(); void set_current_tb_config_index(const int index); Testbench_Config* get_current_Testbench_config(); void set_config_values_in_linear_functions(); bool free_resources(); void set_CSV_Writer_parameter(); void set_CSV_Reader_row(const int start_row); void set_CSV_Reader_to_beginning(); void reset_States(); void reset_States_and_Slave_Agents(); void simulate(unsigned int rounds); vector& get_all_registeredAgents(); ~Testbench(); /* private: unsigned int num_of_registered_agents; Agent* registered_agents[MAX_NUM_OF_AGENTS]; unsigned int num_of_registered_channels; Channel* registered_channels[MAX_NUM_OF_CHANNELS]; unsigned int num_of_registered_sensors; Sensor* registered_sensors[MAX_NUM_OF_SENSORS]; CSV_Reader* registered_sensors_csvr[MAX_NUM_OF_SENSORS]; bool flag_sensor_has_csvr[MAX_NUM_OF_SENSORS]; //csv CSV_Reader* csv_reader; bool flag_csv_reader_exist; CSV_Writer* csv_writer; bool flag_csv_writer_exist; public: Testbench(); Testbench(char* name); void simulate(); //for agents: unsigned int get_num_of_registered_agents(); bool register_agent(Agent* agent); bool deregister_agent(Agent* agent); bool deregister_agent(unsigned int agent_ix); bool get_ix_of_agent(Agent* agent, unsigned int *agent_ix); //for sensors: unsigned int get_num_of_registered_sensors(); bool register_sensor(Sensor* sensor); bool register_sensor(Sensor* sensor, CSV_Reader *csvr); bool deregister_sensor(Sensor* sensor); bool deregister_sensor(unsigned int sensor_ix); bool get_ix_of_sensor(Sensor* sensor, unsigned int *sensor_ix); bool get_flag_sensor_has_csvr(unsigned int sensor_ix); CSV_Reader* get_registered_sensors_csvr(unsigned int sensor_ix); CSV_Reader* get_registered_sensors_csvr(Sensor* sensor); //for channels: unsigned int get_num_of_registered_channels(); bool register_channel(Channel* channel); bool deregister_channel(Channel* channel); bool deregister_channel(unsigned int channel_ix); bool get_ix_of_channel(Channel* channel, unsigned int *channel_ix); //csv bool register_csv_reader(CSV_Reader* csv_reader); bool register_csv_writer(CSV_Writer* csv_writer); */ }; #endif diff --git a/Version_Max_07_05_2018_CMake/src/Testbench_Config.cpp b/Version_Max_07_05_2018_CMake/src/Testbench_Config.cpp index 5bfe52d..2aefc48 100755 --- a/Version_Max_07_05_2018_CMake/src/Testbench_Config.cpp +++ b/Version_Max_07_05_2018_CMake/src/Testbench_Config.cpp @@ -1,228 +1,234 @@ /* * Testbench_Config.cpp * * Created on: 26.06.2018 * Author: edwin */ #include "Testbench_Config.h" vector Testbench_Config::s_vec_all_created_Configs; int Testbench_Config::s_counter_of_all_created_configs = 0; int Testbench_Config::s_active_Config = 0; /* * */ void Testbench_Config::register_Config() { if(s_vec_all_created_Configs.max_size() > s_vec_all_created_Configs.size()){ s_vec_all_created_Configs.push_back(this); this->m_current_index = s_counter_of_all_created_configs; s_counter_of_all_created_configs = s_counter_of_all_created_configs + 1; } else { cout << "It is not possible to add an Testbench_Config to vector, Testbench_Config not registered" << endl; } } /* * */ void Testbench_Config::deregister_Config() { if (!s_vec_all_created_Configs.empty()) { int index = 0; int old_max_index = 0; std::vector::iterator it = s_vec_all_created_Configs.begin(); for (; index != this->m_current_index; it++) { index = index + 1; } old_max_index = s_vec_all_created_Configs.size() -1; if (index == this->m_current_index) { s_vec_all_created_Configs.erase(it); } if(index < old_max_index) { adapt_Indices(index); } this->m_current_index = s_object_is_deleted; s_counter_of_all_created_configs = s_counter_of_all_created_configs - 1; } } /* * */ void Testbench_Config::adapt_Indices(int from_index_to_change) { int index = 0; for(index = 0; index < s_vec_all_created_Configs.size(); index++){ if(index >= from_index_to_change) { Testbench_Config* cur_config = s_vec_all_created_Configs[index]; cur_config->m_current_index = cur_config->m_current_index - 1; } } } Testbench_Config::Testbench_Config() { this->configuration.bound_broken = float(2); - this->configuration.outter_bound_sim_dif = 0.20; - this->configuration.inner_bound_sim_dif = 0.01; + this->configuration.outter_bound_sim_dif = (float)0.20; + this->configuration.inner_bound_sim_dif = (float)0.01; this->configuration.outter_bound_drift = 3 * this->configuration.outter_bound_sim_dif; this->configuration.inner_bound_drift = this->configuration.outter_bound_sim_dif; this->configuration.length = (float) 10; register_Config(); } /* * */ Testbench_Config::Testbench_Config(One_Config_t& a_config) { this->configuration = a_config; register_Config(); } /* * return the index of the object in the static class vector */ int Testbench_Config::get_own_index() { return this->m_current_index; } /* * */ One_Config_t Testbench_Config::get_Config() { - if(this != NULL && this->m_current_index != s_object_is_deleted){ + One_Config_t dummy_config; + //if(this != NULL && this->m_current_index != s_object_is_deleted){ + if (this->m_current_index != s_object_is_deleted) { + this->configuration.valid = true; return this->configuration; } + dummy_config.valid = false; + return dummy_config; } /* * */ void Testbench_Config::print() { - if(this != NULL && this->m_current_index != s_object_is_deleted) { + //if (this != NULL && this->m_current_index != s_object_is_deleted) { + if (this->m_current_index != s_object_is_deleted) { std::cout << "Index of the configuration: " << this->m_current_index; std::cout << "The values of the configuration are: "; std::cout << "Broken boundary: " << this->configuration.bound_broken << " "; std::cout << "Inner boundary similar state: " << this->configuration.inner_bound_sim_dif << " "; std::cout << "Outter boundary similar state: " << this->configuration.outter_bound_sim_dif << " "; std::cout << "Inner boundary drift: " << this->configuration.inner_bound_drift << " "; std::cout << "Outter boundary drift: " << this->configuration.outter_bound_drift << " "; std::cout << "Length: " << this->configuration.length << " "; std::cout << std::endl; }else { std::cout << "Object points to NULL" << std::endl; } } /** * returns the index of the active config of the Testbench. */ int Testbench_Config::get_active_Config() { return s_active_Config; } /** * Sets the index for the current config used. * @param index value >= 0, -1 = Invalid Index * */ void Testbench_Config::set_active_Config(const int index) { if(index < s_counter_of_all_created_configs) { s_active_Config = index; }else { s_active_Config = s_INVALID_INDEX; } } void Testbench_Config::cut_number_of_decimal_digits(std::string & str_number) { const std::string delimeter = "."; const std::string zero = "0"; std::string str_temp; std::size_t first_pos; std::size_t length; std::size_t first_not_zero; std::size_t index; length = str_number.length(); first_pos = str_number.find_first_of(delimeter); if (first_pos != std::string::npos) { //0 is the start of the string, add 1 to get also the delimeter into the string str_temp =str_number.substr(0, first_pos + 1); length = length - first_pos - 1; str_number = str_number.substr(first_pos + 1, length); first_not_zero = str_number.find_first_not_of(zero); if(first_not_zero == std::string::npos) { str_number = str_temp + str_number[0] + str_number[1]; } else { for(index = 0; index <= first_not_zero; index++){ str_temp = str_temp + str_number[index]; } str_number = str_temp; } } } /** * returns all parameters of the config as a string. * B_b means bound broken border, I_B_d means inner bound drift border * O_B_d means outter bound drift border, I_B_s_d means inner bound simular signal border * O_B_s_d means outter bound simular signalr border */ std::string Testbench_Config::get_Config_as_String() { //Ali for file name compatebility in Windows, all ':' chars converted to '-', also blanks removed or changed to '_' std::string config; std::string str_part; str_part = std::to_string(this->configuration.bound_broken); cut_number_of_decimal_digits(str_part); config = "_B_b-" + str_part; str_part = std::to_string(this->configuration.inner_bound_drift); cut_number_of_decimal_digits(str_part); config = config + "_I_B_d-"+ str_part; str_part = std::to_string(this->configuration.outter_bound_drift); cut_number_of_decimal_digits(str_part); config = config + "_O_B_d-" + str_part; str_part = std::to_string(this->configuration.inner_bound_sim_dif); cut_number_of_decimal_digits(str_part); config = config + "_I_B_s_d-" + str_part; str_part = std::to_string(this->configuration.outter_bound_sim_dif); cut_number_of_decimal_digits(str_part); config = config + "_O_B_s_d-" + str_part + ""; config = config + "_Length-" + std::to_string(this->configuration.length) + ""; return config; } /* * */ Testbench_Config::~Testbench_Config() { deregister_Config(); } diff --git a/Version_Max_07_05_2018_CMake/src/Testbench_Config.h b/Version_Max_07_05_2018_CMake/src/Testbench_Config.h index b4af2cd..14877bd 100755 --- a/Version_Max_07_05_2018_CMake/src/Testbench_Config.h +++ b/Version_Max_07_05_2018_CMake/src/Testbench_Config.h @@ -1,72 +1,74 @@ /* * Testbench_Config.h * * Created on: 26.06.2018 * Author: edwin */ #ifndef TESTBENCH_CONFIG_H_ #define TESTBENCH_CONFIG_H_ #include #include #include #include #include using namespace std; typedef struct One_Config { ///parameter of outter boundary for similar function float outter_bound_sim_dif; ///parameter of inner boundary for similar function float inner_bound_sim_dif; ///parameters of outter boundary for drift. float outter_bound_drift; ///parameters of inner boundary for drift. float inner_bound_drift; ///timer telling, after downsampling how many samples after input has changed it is allowed ///that output is changing, for very slow system high value and for fast system low value float bound_broken; ///length where fuzzy function raises from 0 to 1 or 1 to 0 for the complementery. ///history of the data depends of it, and should change, if it changes. int length; + //to show if the config was parameterised correctly. + bool valid; } One_Config_t; class Testbench_Config { private: static vector s_vec_all_created_Configs; static int s_counter_of_all_created_configs; static int s_active_Config; const static int s_object_is_deleted = -1; const static int s_INVALID_INDEX = -1; const static int s_MAX_LENGTH_FLOAT_STRING = 20; int m_current_index; One_Config_t configuration; void register_Config(); void deregister_Config(); void adapt_Indices(int from_index_to_change); void cut_number_of_decimal_digits(std::string & str_number); public: Testbench_Config(); Testbench_Config(One_Config_t& a_config); int get_own_index(); One_Config_t get_Config(); void print(); string get_Config_as_String(); ~Testbench_Config(); static int get_active_Config(); static void set_active_Config(const int index); }; #endif /* TESTBENCH_CONFIG_H_ */ diff --git a/Version_Max_07_05_2018_CMake/src/attach_modules.cpp b/Version_Max_07_05_2018_CMake/src/attach_modules.cpp index fd915b9..c4d6f21 100755 --- a/Version_Max_07_05_2018_CMake/src/attach_modules.cpp +++ b/Version_Max_07_05_2018_CMake/src/attach_modules.cpp @@ -1,60 +1,60 @@ #include "attach_modules.h" #include "rlutil.h" #define PRINT using namespace rlutil; bool attach_historyModuleToSensorSlotInAgent(Agent* agent, Sensor* sensor, Channel* inputPort, HistoryModule* historyModule) { if(agent != NULL && inputPort != NULL && historyModule != NULL) { SensorSlotOfAgent* sensorSlotOfAgent = agent->get_sensorHandlerOfAgent()->get_sensorSlotAddress(inputPort); if(sensorSlotOfAgent != NULL) { #ifdef PRINT printf(" > HistoryModule "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", historyModule->get_name()); + printf("%s ", historyModule->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) ", historyModule->get_id()); #endif // PRINT if(sensorSlotOfAgent->set_historyModule(historyModule)) { #ifdef PRINT setColor(TXTCOLOR_LIGHTGREEN); printf("attached "); setColor(TXTCOLOR_GREY); printf("to Sensor "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", sensor->get_name()); + printf("%s ", sensor->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) in Agent ", sensor->get_id()); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", agent->get_name()); + printf("%s ", agent->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", agent->get_id()); #endif // PRINT return true; } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf("Couldn't attach the HistoryModule!\n"); setColor(TXTCOLOR_GREY); #endif // PRINT } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf(" > Couldn't attach the HistoryModule because Sensor isn't mounted in %s (id: %03u)!\n", agent->get_name(), agent->get_id()); + printf(" > Couldn't attach the HistoryModule because Sensor isn't mounted in %s (id: %03u)!\n", agent->get_name().c_str(), agent->get_id()); setColor(TXTCOLOR_GREY); #endif // PRINT } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf(" > Couldn't attach the HistoryModule because Agent, Channel, or HistoryModule is not valid!\n"); setColor(TXTCOLOR_GREY); #endif // PRINT } return false; } \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/attach_modulesToTestbench.cpp b/Version_Max_07_05_2018_CMake/src/attach_modulesToTestbench.cpp index 91c1c8a..d90ffe6 100755 --- a/Version_Max_07_05_2018_CMake/src/attach_modulesToTestbench.cpp +++ b/Version_Max_07_05_2018_CMake/src/attach_modulesToTestbench.cpp @@ -1,62 +1,62 @@ #include "attach_modulesToTestbench.h" #include "rlutil.h" #include "SensorSlotOfTestbench.h" #define PRINT using namespace rlutil; bool attach_csvReaderModuleToSensorSlotInAgent(Testbench* testbench, Sensor* sensor, CSVreaderModule* csvReaderModule) { if(testbench != NULL && sensor != NULL && csvReaderModule != NULL) { SensorSlotOfTestbench* sensorSlot = testbench->get_sensorSlotAddressOfTestbench(sensor); if(sensorSlot != NULL) { #ifdef PRINT printf(" > CSV-Reader "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", csvReaderModule->get_name()); + printf("%s ", csvReaderModule->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) ", csvReaderModule->get_id()); #endif // PRINT if(sensorSlot->set_csvReaderModule(csvReaderModule)) { #ifdef PRINT setColor(TXTCOLOR_LIGHTGREEN); printf("attached "); setColor(TXTCOLOR_GREY); printf("to Sensor "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", sensor->get_name()); + printf("%s ", sensor->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) in Testbench ", sensor->get_id()); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", testbench->get_name()); + printf("%s ", testbench->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", testbench->get_id()); #endif // PRINT return true; } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf("Couldn't attach the CSVreaderModule!\n"); setColor(TXTCOLOR_GREY); #endif // PRINT } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf(" > Couldn't attach the CSVreaderModule because Sensor isn't registered in %s (id: %03u)!\n", testbench->get_name(), testbench->get_id()); + printf(" > Couldn't attach the CSVreaderModule because Sensor isn't registered in %s (id: %03u)!\n", testbench->get_name().c_str(), testbench->get_id()); setColor(TXTCOLOR_GREY); #endif // PRINT } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf(" > Couldn't attach the CSVreaderModule because Testbench, Sensorm or CSVreaderModule is not valid!\n"); setColor(TXTCOLOR_GREY); #endif // PRINT } return false; } \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.cpp b/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.cpp index a8ca1e2..177f483 100644 --- a/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.cpp +++ b/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.cpp @@ -1 +1,517 @@ -// test 123 \ No newline at end of file +#include "Agent.h" +#include "CSVreaderModule.h" +#include "Channel.h" +#include "Sensor.h" +#include "Testbench.h" +#include "create_unit.h" +#include "file_util.h" +#include "inAgentsRegistrations.h" +#include "mount_nodes.h" +#include "register_in_testbench.h" +#include "setupNode.h" + +#include "LinearFunction.h" +#include "LinearFunctionBlock.h" + + +#define PRINT +#define STOP_BEFORE_SIMULATING + + +void configAndStartNewMotorExperiment( + char *destinationPath, char *datasetPath, char *datasetName, + unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif, + int boundTimeInSamples, float innerBoundDrift, float outerBoundDrift, + int boundBrokenTime, int downSamplingFactor) { + + //config starts here + // create agents + // low level agents - inputs + Agent* a_statorVoltage = create_agent("Stator Voltage"); + setWorkingCycleOfAgent(a_statorVoltage, downSamplingFactor); + Agent* a_inputFrequency = create_agent("Input Frequency"); + setWorkingCycleOfAgent(a_inputFrequency, downSamplingFactor); + Agent* a_mechanicalTorque = create_agent("Mechanical Torque"); + setWorkingCycleOfAgent(a_mechanicalTorque, downSamplingFactor); + // low level agents - outputs + Agent* a_statorCurrent = create_agent("Stator Current"); + setWorkingCycleOfAgent(a_statorCurrent, downSamplingFactor); + Agent* a_electromagneticTorque = create_agent("Electromagnetic Torque"); + setWorkingCycleOfAgent(a_electromagneticTorque, downSamplingFactor); + Agent* a_speed = create_agent("Speed"); + setWorkingCycleOfAgent(a_speed, downSamplingFactor); + // high level agent + Agent* a_viabilityMonitor = create_agent("Viability Monitor"); + setWorkingCycleOfAgent(a_viabilityMonitor, downSamplingFactor); + + // create sensors + // inputs + Sensor* s_statorVoltage = create_sensor("Stator Voltage"); + setWorkingCycleOfSensor(s_statorVoltage, downSamplingFactor); + Sensor* s_inputFrequency = create_sensor("Input Frequency"); + setWorkingCycleOfSensor(s_inputFrequency, downSamplingFactor); + Sensor* s_mechanicalTorque = create_sensor("Mechanical Torque"); + setWorkingCycleOfSensor(s_mechanicalTorque, downSamplingFactor); + // outputs + Sensor* s_statorCurrent = create_sensor("Stator Current"); + setWorkingCycleOfSensor(s_statorCurrent, downSamplingFactor); + Sensor* s_electromagneticTorque = create_sensor("Electromagnetic Torque"); + setWorkingCycleOfSensor(s_electromagneticTorque, downSamplingFactor); + Sensor* s_speed = create_sensor("Speed"); + setWorkingCycleOfSensor(s_speed, downSamplingFactor); + + // create channels for sensors + // inputs + Channel* c_sa_statorVoltage = create_channel("Stator Voltage (SA)", 0); + Channel* c_sa_inputFrequency = create_channel("Input Frequency (SA)", 0); + Channel* c_sa_mechanicalTorque = create_channel("Mechanical Torque (SA)", 0); + // outputs + Channel* c_sa_statorCurrent = create_channel("Stator Current (SA)", 0); + Channel* c_sa_electromagneticTorque = + create_channel("Electromagnetic Torque (SA)", 0); + Channel* c_sa_speed = create_channel("Speed Sensor (SA)", 0); + + // create channels for sensors + // inputs + Channel* c_aa_statorVoltage = + create_channel("Stator Voltage (AA-UP)", MAX_BUFFER_LENGTH); + Channel* c_aa_inputFrequency = + create_channel("Input Frequency (AA-UP)", MAX_BUFFER_LENGTH); + Channel* c_aa_mechanicalTorque = + create_channel("Mechanical Torque (AA-UP)", MAX_BUFFER_LENGTH); + // outputs + Channel* c_aa_statorCurrent = + create_channel("Stator Current (AA-UP)", MAX_BUFFER_LENGTH); + Channel* c_aa_electromagneticTorque = + create_channel("Electromagnetic Torque (AA-UP)", MAX_BUFFER_LENGTH); + Channel* c_aa_speed = + create_channel("Speed Sensor (AA-UP)", MAX_BUFFER_LENGTH); + + + + + + + + + + // mount sensors in agents + // inputs + mount_sensorInAgent(a_statorVoltage, s_statorVoltage, c_sa_statorVoltage); + mount_sensorInAgent(a_inputFrequency, s_inputFrequency, + c_sa_inputFrequency); + mount_sensorInAgent(a_mechanicalTorque, s_mechanicalTorque, + c_sa_mechanicalTorque); + // outputs + mount_sensorInAgent(a_statorCurrent, s_statorCurrent, c_sa_statorCurrent); + mount_sensorInAgent(a_electromagneticTorque, s_electromagneticTorque, + c_sa_electromagneticTorque); + mount_sensorInAgent(a_speed, s_speed, c_sa_speed); + + // mount agents in agent(s) + // inputs + mount_agentInAgent(a_viabilityMonitor, a_statorVoltage, + c_aa_statorVoltage); + mount_agentInAgent(a_viabilityMonitor, a_inputFrequency, + c_aa_inputFrequency); + mount_agentInAgent(a_viabilityMonitor, a_mechanicalTorque, + c_aa_mechanicalTorque); + // outputs + mount_agentInAgent(a_viabilityMonitor, a_statorCurrent, + c_aa_statorCurrent); + mount_agentInAgent(a_viabilityMonitor, a_electromagneticTorque, + c_aa_electromagneticTorque); + mount_agentInAgent(a_viabilityMonitor, a_speed, c_aa_speed); + + // register agents in agents' stateHandler + // inputs + registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor, + c_aa_statorVoltage); + registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor, + c_aa_inputFrequency); + registerSlaveAgentAsInputVariableInStateHandler(a_viabilityMonitor, + c_aa_mechanicalTorque); + // outputs + registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor, + c_aa_statorCurrent); + registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor, + c_aa_electromagneticTorque); + registerSlaveAgentAsOutputVariableInStateHandler(a_viabilityMonitor, + c_aa_speed); + + // SAME STATE DEVIATION + LinearFunctionBlock confSim2StateDev("funcBlock:confSim2StateDev"); + LinearFunction funcConfSim2StateDev1; + funcConfSim2StateDev1.setDomain(false, true, -1 * outerBoundSimDif); + funcConfSim2StateDev1.setKandD((float)0, (float)0); + confSim2StateDev.addLinearFunction(&funcConfSim2StateDev1); + LinearFunction funcConfSim2StateDev2; + funcConfSim2StateDev2.setDomain(true, -1 * outerBoundSimDif, true, + -1 * innerBoundSimDif); + funcConfSim2StateDev2.setKandD(-1 * outerBoundSimDif, (float)0, + -1 * innerBoundSimDif, (float)1); + confSim2StateDev.addLinearFunction(&funcConfSim2StateDev2); + LinearFunction funcConfSim2StateDev3; + funcConfSim2StateDev3.setDomain(true, -1 * innerBoundSimDif, true, + innerBoundSimDif); + funcConfSim2StateDev3.setKandD((float)0, (float)1); + confSim2StateDev.addLinearFunction(&funcConfSim2StateDev3); + LinearFunction funcConfSim2StateDev4; + funcConfSim2StateDev4.setDomain(true, innerBoundSimDif, true, + outerBoundSimDif); + funcConfSim2StateDev4.setKandD(innerBoundSimDif, (float)1, outerBoundSimDif, + (float)0); + confSim2StateDev.addLinearFunction(&funcConfSim2StateDev4); + LinearFunction funcConfSim2StateDev5; + funcConfSim2StateDev5.setDomain(true, outerBoundSimDif, false); + funcConfSim2StateDev5.setKandD((float)0, (float)0); + confSim2StateDev.addLinearFunction(&funcConfSim2StateDev5); +#ifdef PRINT + confSim2StateDev.printFunctionBlock("funcBlock:confSim2StateDev"); +#endif // PRINT + + // ANOTHER STATE DEVIATION + LinearFunctionBlock confDif2StateDev("funcBlock:confDif2StateDev"); + LinearFunction funcConfDif2StateDev1; + funcConfDif2StateDev1.setDomain(false, true, -1 * outerBoundSimDif); + funcConfDif2StateDev1.setKandD((float)0, (float)1); + confDif2StateDev.addLinearFunction(&funcConfDif2StateDev1); + LinearFunction funcConfDif2StateDev2; + funcConfDif2StateDev2.setDomain(true, -1 * outerBoundSimDif, true, + -1 * innerBoundSimDif); + funcConfDif2StateDev2.setKandD(-1 * outerBoundSimDif, (float)1, + -1 * innerBoundSimDif, (float)0); + confDif2StateDev.addLinearFunction(&funcConfDif2StateDev2); + LinearFunction funcConfDif2StateDev3; + funcConfDif2StateDev3.setDomain(true, -1 * innerBoundSimDif, true, + innerBoundSimDif); + funcConfDif2StateDev3.setKandD((float)0, (float)0); + confDif2StateDev.addLinearFunction(&funcConfDif2StateDev3); + LinearFunction funcConfDif2StateDev4; + funcConfDif2StateDev4.setDomain(true, innerBoundSimDif, true, + outerBoundSimDif); + funcConfDif2StateDev4.setKandD(innerBoundSimDif, (float)0, outerBoundSimDif, + (float)1); + confDif2StateDev.addLinearFunction(&funcConfDif2StateDev4); + LinearFunction funcConfDif2StateDev5; + funcConfDif2StateDev5.setDomain(true, outerBoundSimDif, false); + funcConfDif2StateDev5.setKandD((float)0, (float)1); + confDif2StateDev.addLinearFunction(&funcConfDif2StateDev5); +#ifdef PRINT + confDif2StateDev.printFunctionBlock("funcBlock:confDif2StateDev"); +#endif // PRINT + + // SAME STATE TIME + LinearFunctionBlock confSim2StateTime("funcBlock:confSim2StateTime"); + LinearFunction funcConfSim2StateTime1; + funcConfSim2StateTime1.setDomain(false, true, (float)0); + funcConfSim2StateTime1.setKandD((float)0, (float)0); + confSim2StateTime.addLinearFunction(&funcConfSim2StateTime1); + LinearFunction funcConfSim2StateTime2; + funcConfSim2StateTime2.setDomain(true, (float)0, true, + (float)boundTimeInSamples); + funcConfSim2StateTime2.setKandD((float)0, (float)0, (float)boundTimeInSamples, + (float)1); + confSim2StateTime.addLinearFunction(&funcConfSim2StateTime2); + LinearFunction funcConfSim2StateTime3; + funcConfSim2StateTime3.setDomain(true, (float)boundTimeInSamples, false); + funcConfSim2StateTime3.setKandD((float)0, (float)1); + confSim2StateTime.addLinearFunction(&funcConfSim2StateTime3); +#ifdef PRINT + confSim2StateTime.printFunctionBlock("funcBlock:confSim2StateTime"); +#endif // PRINT + + // ANOTHER STATE TIME + LinearFunctionBlock confDif2StateTime("funcBlock:confDif2StateTime"); + LinearFunction funcConfDif2StateTime1; + funcConfDif2StateTime1.setDomain(false, true, (float)0); + funcConfDif2StateTime1.setKandD((float)0, (float)1); + confDif2StateTime.addLinearFunction(&funcConfDif2StateTime1); + LinearFunction funcConfDif2StateTime2; + funcConfDif2StateTime2.setDomain(true, (float)0, true, + (float)boundTimeInSamples); + funcConfDif2StateTime2.setKandD((float)0, (float)1, (float)boundTimeInSamples, + (float)0); + confDif2StateTime.addLinearFunction(&funcConfDif2StateTime2); + LinearFunction funcConfDif2StateTime3; + funcConfDif2StateTime3.setDomain(true, (float)boundTimeInSamples, false); + funcConfDif2StateTime3.setKandD((float)0, (float)0); + confDif2StateTime.addLinearFunction(&funcConfDif2StateTime3); +#ifdef PRINT + confDif2StateTime.printFunctionBlock("funcBlock:confDif2StateTime"); +#endif // PRINT + + /************************ FunctionBlocks Val/Inv State (NEU) + * ************************/ + + // VALID STATE DEVIATION + LinearFunctionBlock confValidStateDev("funcBlock:confValidStateDev"); + LinearFunction funcConfValidStateDev1; + funcConfValidStateDev1.setDomain(false, true, -1 * outerBoundSimDif); + funcConfValidStateDev1.setKandD((float)0, (float)0); + confValidStateDev.addLinearFunction(&funcConfValidStateDev1); + LinearFunction funcConfValidStateDev2; + funcConfValidStateDev2.setDomain(true, -1 * outerBoundSimDif, true, + -1 * innerBoundSimDif); + funcConfValidStateDev2.setKandD(-1 * outerBoundSimDif, (float)0, + -1 * innerBoundSimDif, (float)1); + confValidStateDev.addLinearFunction(&funcConfValidStateDev2); + LinearFunction funcConfValidStateDev3; + funcConfValidStateDev3.setDomain(true, -1 * innerBoundSimDif, true, + innerBoundSimDif); + funcConfValidStateDev3.setKandD((float)0, (float)1); + confValidStateDev.addLinearFunction(&funcConfValidStateDev3); + LinearFunction funcConfValidStateDev4; + funcConfValidStateDev4.setDomain(true, innerBoundSimDif, true, + outerBoundSimDif); + funcConfValidStateDev4.setKandD(innerBoundSimDif, (float)1, outerBoundSimDif, + (float)0); + confValidStateDev.addLinearFunction(&funcConfValidStateDev4); + LinearFunction funcConfValidStateDev5; + funcConfValidStateDev5.setDomain(true, outerBoundSimDif, false); + funcConfValidStateDev5.setKandD((float)0, (float)0); + confValidStateDev.addLinearFunction(&funcConfValidStateDev5); +#ifdef PRINT + confValidStateDev.printFunctionBlock("funcBlock:confValidStateDev"); +#endif // PRINT + + // INVALID STATE DEVIATION + LinearFunctionBlock confInvalidStateDev("funcBlock:confInvalidStateDev"); + LinearFunction funcConfInvalidStateDev1; + funcConfInvalidStateDev1.setDomain(false, true, -1 * outerBoundSimDif); + funcConfInvalidStateDev1.setKandD((float)0, (float)1); + confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev1); + LinearFunction funcConfInvalidStateDev2; + funcConfInvalidStateDev2.setDomain(true, -1 * outerBoundSimDif, true, + -1 * innerBoundSimDif); + funcConfInvalidStateDev2.setKandD(-1 * outerBoundSimDif, (float)1, + -1 * innerBoundSimDif, (float)0); + confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev2); + LinearFunction funcConfInvalidStateDev3; + funcConfInvalidStateDev3.setDomain(true, -1 * innerBoundSimDif, true, + innerBoundSimDif); + funcConfInvalidStateDev3.setKandD((float)0, (float)0); + confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev3); + LinearFunction funcConfInvalidStateDev4; + funcConfInvalidStateDev4.setDomain(true, innerBoundSimDif, true, + outerBoundSimDif); + funcConfInvalidStateDev4.setKandD(innerBoundSimDif, (float)0, + outerBoundSimDif, (float)1); + confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev4); + LinearFunction funcConfInvalidStateDev5; + funcConfInvalidStateDev5.setDomain(true, outerBoundSimDif, false); + funcConfInvalidStateDev5.setKandD((float)0, (float)1); + confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev5); +#ifdef PRINT + confInvalidStateDev.printFunctionBlock("funcBlock:confInvalidStateDev"); +#endif // PRINT + + // VALID STATE TIME + LinearFunctionBlock confValidStateTime("funcBlock:confValidStateTime"); + LinearFunction funcConfValidStateTime1; + funcConfValidStateTime1.setDomain(false, true, (float)0); + funcConfValidStateTime1.setKandD((float)0, (float)0); + confValidStateTime.addLinearFunction(&funcConfValidStateTime1); + LinearFunction funcConfValidStateTime2; + funcConfValidStateTime2.setDomain(true, (float)0, true, + (float)boundTimeInSamples); // 10 + funcConfValidStateTime2.setKandD((float)0, (float)0, + (float)boundTimeInSamples, (float)1); + confValidStateTime.addLinearFunction(&funcConfValidStateTime2); + LinearFunction funcConfValidStateTime3; + funcConfValidStateTime3.setDomain(true, (float)boundTimeInSamples, false); + funcConfValidStateTime3.setKandD((float)0, (float)1); + confValidStateTime.addLinearFunction(&funcConfValidStateTime3); +#ifdef PRINT + confValidStateTime.printFunctionBlock("funcBlock:confValidStateTime"); +#endif // PRINT + + // INVALID STATE TIME + LinearFunctionBlock confInvalidStateTime("funcBlock:confInvalidStateTime"); + LinearFunction funcConfInvalidStateTime1; + funcConfInvalidStateTime1.setDomain(false, true, (float)0); + funcConfInvalidStateTime1.setKandD((float)0, (float)1); + confInvalidStateTime.addLinearFunction(&funcConfInvalidStateTime1); + LinearFunction funcConfInvalidStateTime2; + funcConfInvalidStateTime2.setDomain(true, (float)0, true, + (float)boundTimeInSamples); + funcConfInvalidStateTime2.setKandD((float)0, (float)1, + (float)boundTimeInSamples, + (float)0); + confInvalidStateTime.addLinearFunction(&funcConfInvalidStateTime2); + LinearFunction funcConfInvalidStateTime3; + funcConfInvalidStateTime3.setDomain(true, (float)boundTimeInSamples, false); + funcConfInvalidStateTime3.setKandD((float)0, (float)0); + confInvalidStateTime.addLinearFunction(&funcConfInvalidStateTime3); +#ifdef PRINT + confInvalidStateTime.printFunctionBlock("funcBlock:confInvalidStateTime"); +#endif // PRINT + + /********************************** Functions NOT OK + * **********************************/ + + LinearFunctionBlock confStateDrifts("confidence:confStateDrifts"); + LinearFunction functionConfidenceDriftDeviation1; + functionConfidenceDriftDeviation1.setDomain(false, true, + -1 * outerBoundDrift); + functionConfidenceDriftDeviation1.setKandD((float)0, (float)1); + confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation1); + LinearFunction functionConfidenceDriftDeviation2; + functionConfidenceDriftDeviation2.setDomain(true, -1 * outerBoundDrift, true, + -1 * outerBoundDrift); + functionConfidenceDriftDeviation2.setKandD(-1 * outerBoundDrift, (float)1, + -1 * outerBoundDrift, (float)0); + confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation2); + LinearFunction functionConfidenceDriftDeviation3; + functionConfidenceDriftDeviation3.setDomain(true, -1 * outerBoundDrift, true, + outerBoundDrift); + functionConfidenceDriftDeviation3.setKandD((float)0, (float)0); + confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation3); + LinearFunction functionConfidenceDriftDeviation4; + functionConfidenceDriftDeviation4.setDomain(true, outerBoundDrift, true, + outerBoundDrift); + functionConfidenceDriftDeviation4.setKandD(outerBoundDrift, (float)0, + outerBoundDrift, (float)1); + confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation4); + LinearFunction functionConfidenceDriftDeviation5; + functionConfidenceDriftDeviation5.setDomain(true, outerBoundDrift, false); + functionConfidenceDriftDeviation5.setKandD((float)0, (float)1); + confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation5); +#ifdef PRINT + confStateDrifts.printFunctionBlock("confidence:confStateDrifts"); +#endif // PRINT + + LinearFunctionBlock confBroken("confidence:broken"); + LinearFunction functionConfidenceBroken1; + functionConfidenceBroken1.setDomain(false, true, (float)0); + functionConfidenceBroken1.setKandD((float)0, (float)0); + confBroken.addLinearFunction(&functionConfidenceBroken1); + LinearFunction functionConfidenceBroken2; + functionConfidenceBroken2.setDomain(true, (float)0, true, + (float)boundBrokenTime); + functionConfidenceBroken2.setKandD((float)0, (float)0, (float)boundBrokenTime, + (float)1); + confBroken.addLinearFunction(&functionConfidenceBroken2); + LinearFunction functionConfidenceBroken3; + functionConfidenceBroken3.setDomain(true, (float)boundBrokenTime, false); + functionConfidenceBroken3.setKandD((float)0, (float)1); + confBroken.addLinearFunction(&functionConfidenceBroken3); +#ifdef PRINT + confBroken.printFunctionBlock("confidence:broken"); +#endif // PRINT + + + + + +/********************************** Mount Functions + * **********************************/ +//TODO: make FuncBlockConfSim2StateDev etc. private and write a setFunction! + + //aaaaaaaaaa + a_viabilityMonitor->set_stateHandler("CSVW:CAMoutput", destinationPath); + + a_viabilityMonitor->get_stateHandler()->FuncBlockConfSim2StateDev = + &confSim2StateDev; + a_viabilityMonitor->get_stateHandler()->FuncBlockConfDif2StateDev = + &confDif2StateDev; + a_viabilityMonitor->get_stateHandler()->FuncBlockConfSim2StateTime = + &confSim2StateTime; + a_viabilityMonitor->get_stateHandler()->FuncBlockConfDif2StateTime = + &confDif2StateTime; + + a_viabilityMonitor->get_stateHandler()->FuncBlockConfValStateDev = + &confValidStateDev; + a_viabilityMonitor->get_stateHandler()->FuncBlockConfInvStateDev = + &confInvalidStateDev; + a_viabilityMonitor->get_stateHandler()->FuncBlockConfValStateTime = + &confValidStateTime; + a_viabilityMonitor->get_stateHandler()->FuncBlockConfInvStateTime = + &confInvalidStateTime; + + // HIIIIIIIIIIIIIIERRRRRRRRRRRR SCH种种种种种种种种种諲ER MACHEN + a_viabilityMonitor->get_stateHandler()->DriftDeviation = &confStateDrifts; + a_viabilityMonitor->get_stateHandler()->FuncBlockConfBrokenSamples = + &confBroken; + + a_viabilityMonitor->get_stateHandler()->setMaxStateHistoryLength( + boundTimeInSamples); + + //a_viabilityMonitor->get_stateHandler()->setCSVwriter(destinationPath); + + // New for Revision CAM + // a_viabilityMonitor.get_stateHandler()->FuncBlockConfBrokenSamplesChangeInOldState + // = &confBrokenChangeInOldState; + + // create testbench + Testbench* tb = create_testbench("testbench"); + + // create CSV reader modules + unsigned int ROW = 2; + // inputs + CSVreaderModule* csvr_statorVoltage = + create_CSVreaderModule("CSVR:StatorVoltage", datasetPath, 3, ROW); + CSVreaderModule* csvr_inputFrequency = + create_CSVreaderModule("CSVR:InputFrequency", datasetPath, 6, ROW); + CSVreaderModule* csvr_mechanicalTorque = + create_CSVreaderModule("CSVR:mTorque", datasetPath, 7, ROW); + // outputs + CSVreaderModule* csvr_statorCurrent = + create_CSVreaderModule("CSVR:StatorCurrent", datasetPath, 8, ROW); + CSVreaderModule* csvr_electromagneticTorque = + create_CSVreaderModule("CSVR:eTorque", datasetPath, 11, ROW); + CSVreaderModule* csvr_speed = + create_CSVreaderModule("CSVR:Speed", datasetPath, 12, ROW); + + // register agents + // low level agents - inputs + register_agentInTestbench(tb, a_statorVoltage); + register_agentInTestbench(tb, a_inputFrequency); + register_agentInTestbench(tb, a_mechanicalTorque); + // low level agents - outputs + register_agentInTestbench(tb, a_statorCurrent); + register_agentInTestbench(tb, a_electromagneticTorque); + register_agentInTestbench(tb, a_speed); + // high level agent + register_agentInTestbench(tb, a_viabilityMonitor); + + // register sensors with their csv-readers + // inputs + register_sensorInTestbench(tb, s_statorVoltage, csvr_statorVoltage); + register_sensorInTestbench(tb, s_inputFrequency, csvr_inputFrequency); + register_sensorInTestbench(tb, s_mechanicalTorque, csvr_mechanicalTorque); + // outputs + register_sensorInTestbench(tb, s_statorCurrent, csvr_statorCurrent); + register_sensorInTestbench(tb, s_electromagneticTorque, + csvr_electromagneticTorque); + register_sensorInTestbench(tb, s_speed, csvr_speed); + + // register sensor channels + // sensor-agent channels + // inputs + register_channelInTestbench(tb, c_sa_statorVoltage); + register_channelInTestbench(tb, c_sa_inputFrequency); + register_channelInTestbench(tb, c_sa_mechanicalTorque); + // outputs + register_channelInTestbench(tb, c_sa_statorCurrent); + register_channelInTestbench(tb, c_sa_electromagneticTorque); + register_channelInTestbench(tb, c_sa_speed); + + // agent-agent channels + // inputs + register_channelInTestbench(tb, c_aa_statorVoltage); + register_channelInTestbench(tb, c_aa_inputFrequency); + register_channelInTestbench(tb, c_aa_mechanicalTorque); + // ouputs + register_channelInTestbench(tb, c_aa_statorCurrent); + register_channelInTestbench(tb, c_aa_speed); + register_channelInTestbench(tb, c_aa_electromagneticTorque); + +#ifdef STOP_BEFORE_SIMULATING + getchar(); +#endif + + + tb->simulate(datasetLength); + +} diff --git a/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.h b/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.h new file mode 100644 index 0000000..7902c5d --- /dev/null +++ b/Version_Max_07_05_2018_CMake/src/configCAMforNewMotor.h @@ -0,0 +1,10 @@ +#ifndef HEADER_NEWMOTOR_CONFIG +#define HEADER_NEWMOTOR_CONFIG + +void configAndStartNewMotorExperiment( + char *destinationPath, char *datasetPath, char *datasetName, + unsigned int datasetLength, float innerBoundSimDif, float outerBoundSimDif, + int boundTimeInSamples, float innerBoundDrift, float outerBoundDrift, + int boundBrokenTime, int downSamplingFactor); + +#endif \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/create_unit.cpp b/Version_Max_07_05_2018_CMake/src/create_unit.cpp index be16f5f..448176c 100755 --- a/Version_Max_07_05_2018_CMake/src/create_unit.cpp +++ b/Version_Max_07_05_2018_CMake/src/create_unit.cpp @@ -1,416 +1,419 @@ #include "create_unit.h" -#include #include "errno.h" #include "rlutil.h" +#include using namespace rlutil; #define PRINT -void print_agent(Agent agent) { - -} +void print_agent(Agent agent) {} -Agent* create_agent() { - return create_agent(NO_NAME); -} +Agent *create_agent() { return create_agent(NO_NAME); } -Agent* create_agent(char* name) { - Agent* agent = new Agent(name); -#ifdef PRINT - printf(" > Agent "); - setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", agent->get_name()); - setColor(TXTCOLOR_GREY); - printf("(id: %03u) ", agent->get_id()); - setColor(TXTCOLOR_LIGHTGREEN); - printf("created\n"); - setColor(TXTCOLOR_GREY); +Agent *create_agent(std::string name) { + Agent *agent = new Agent(name); +#ifdef PRINT + printf(" > Agent "); + setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", agent->get_name().c_str()); + setColor(TXTCOLOR_GREY); + printf("(id: %03u) ", agent->get_id()); + setColor(TXTCOLOR_LIGHTGREEN); + printf("created\n"); + setColor(TXTCOLOR_GREY); #endif // PRINT - return agent; + return agent; } +Sensor *create_sensor() { return create_sensor(NO_NAME); } -Sensor* create_sensor() { - return create_sensor(NO_NAME); -} - -Sensor* create_sensor(char* name) { - Sensor* sensor = new Sensor(name); -#ifdef PRINT - printf(" > Sensor "); - setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", sensor->get_name()); - setColor(TXTCOLOR_GREY); - printf("(id: %03u) ", sensor->get_id()); - setColor(TXTCOLOR_LIGHTGREEN); - printf("created\n"); - setColor(TXTCOLOR_GREY); +Sensor *create_sensor(std::string name) { + Sensor *sensor = new Sensor(name); +#ifdef PRINT + printf(" > Sensor "); + setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", sensor->get_name().c_str()); + setColor(TXTCOLOR_GREY); + printf("(id: %03u) ", sensor->get_id()); + setColor(TXTCOLOR_LIGHTGREEN); + printf("created\n"); + setColor(TXTCOLOR_GREY); #endif // PRINT - return sensor; + return sensor; } - -HistoryModule create_historyModule(unsigned int history_length, int delimitation_mode) { - return create_historyModule(NO_NAME, history_length, delimitation_mode); +HistoryModule create_historyModule(unsigned int history_length, + int delimitation_mode) { + return create_historyModule(NO_NAME, history_length, delimitation_mode); } -HistoryModule create_historyModule(char* name, unsigned int history_length, int delimitation_mode) { - - HistoryModule historyModule(name); -#ifdef PRINT - printf(" > History "); - setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", historyModule.get_name()); - setColor(TXTCOLOR_GREY); - printf("(id: %03u) ", historyModule.get_id()); - setColor(TXTCOLOR_LIGHTGREEN); - printf("created\n"); - setColor(TXTCOLOR_GREY); +HistoryModule create_historyModule(std::string name, + unsigned int history_length, + int delimitation_mode) { + + HistoryModule historyModule(name); +#ifdef PRINT + printf(" > History "); + setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", historyModule.get_name().c_str()); + setColor(TXTCOLOR_GREY); + printf("(id: %03u) ", historyModule.get_id()); + setColor(TXTCOLOR_LIGHTGREEN); + printf("created\n"); + setColor(TXTCOLOR_GREY); #endif // PRINT - if(historyModule.set_maxHistoryLength(history_length)) { + if (historyModule.set_maxHistoryLength(history_length)) { #ifdef PRINT - printf(" > History length "); - setColor(TXTCOLOR_LIGHTGREEN); - printf("set "); - setColor(TXTCOLOR_GREY); - printf("to %u\n", history_length); + printf(" > History length "); + setColor(TXTCOLOR_LIGHTGREEN); + printf("set "); + setColor(TXTCOLOR_GREY); + printf("to %u\n", history_length); #endif // PRINT - } - else { - setColor(TXTCOLOR_LIGHTRED); - printf(" > historyLength could not set (out of allowed range)."); - setColor(TXTCOLOR_GREY); - } - if(historyModule.set_delimitationMode(delimitation_mode)) { + } else { + setColor(TXTCOLOR_LIGHTRED); + printf(" > historyLength could not set (out of allowed range)."); + setColor(TXTCOLOR_GREY); + } + if (historyModule.set_delimitationMode(delimitation_mode)) { #ifdef PRINT - printf(" > Delimitation Mode "); - setColor(TXTCOLOR_LIGHTGREEN); - printf("set "); - setColor(TXTCOLOR_GREY); - printf("to %u\n", delimitation_mode); + printf(" > Delimitation Mode "); + setColor(TXTCOLOR_LIGHTGREEN); + printf("set "); + setColor(TXTCOLOR_GREY); + printf("to %u\n", delimitation_mode); #endif // PRINT - } - else { - setColor(TXTCOLOR_LIGHTRED); - printf(" > Delimitation Mode could not set (out of allowed range)."); - setColor(TXTCOLOR_GREY); - } - - return historyModule; + } else { + setColor(TXTCOLOR_LIGHTRED); + printf(" > Delimitation Mode could not set (out of allowed range)."); + setColor(TXTCOLOR_GREY); + } + + return historyModule; } -Channel* create_channel(unsigned int transfer_rate) { - return create_channel(NO_NAME, transfer_rate); +Channel *create_channel(unsigned int transfer_rate) { + return create_channel(NO_NAME, transfer_rate); } -Channel* create_channel(char* name, unsigned int transfer_rate) { +Channel *create_channel(std::string name, unsigned int transfer_rate) { - Channel* channel = new Channel(name); + Channel *channel = new Channel(name); #ifdef PRINT - printf(" > Channel "); - setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", channel->get_name()); - setColor(TXTCOLOR_GREY); - printf("(id: %03u) ", channel->get_id()); - setColor(TXTCOLOR_LIGHTGREEN); - printf("created\n"); - setColor(TXTCOLOR_GREY); + printf(" > Channel "); + setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", channel->get_name().c_str()); + setColor(TXTCOLOR_GREY); + printf("(id: %03u) ", channel->get_id()); + setColor(TXTCOLOR_LIGHTGREEN); + printf("created\n"); + setColor(TXTCOLOR_GREY); #endif // PRINT - if(channel->set_transferRate(transfer_rate)) { - if(transfer_rate != 0) { -#ifdef PRINT - printf(" > transfer rate "); - setColor(TXTCOLOR_LIGHTGREEN); - printf("set "); - setColor(TXTCOLOR_GREY); - printf("to %i\n", transfer_rate); + if (channel->set_transferRate(transfer_rate)) { + if (transfer_rate != 0) { +#ifdef PRINT + printf(" > transfer rate "); + setColor(TXTCOLOR_LIGHTGREEN); + printf("set "); + setColor(TXTCOLOR_GREY); + printf("to %i\n", transfer_rate); #endif // PRINT - } - else { -#ifdef PRINT - printf(" > transfer "); - setColor(TXTCOLOR_LIGHTGREEN); - printf("set "); - setColor(TXTCOLOR_GREY); - printf("to immediately transportation\n"); + } else { +#ifdef PRINT + printf(" > transfer "); + setColor(TXTCOLOR_LIGHTGREEN); + printf("set "); + setColor(TXTCOLOR_GREY); + printf("to immediately transportation\n"); #endif // PRINT - } - } - else { -#ifdef PRINT - setColor(TXTCOLOR_LIGHTRED); - printf(" > Transfer Rate out of allowed bounds!\n"); - setColor(TXTCOLOR_GREY); + } + } else { +#ifdef PRINT + setColor(TXTCOLOR_LIGHTRED); + printf(" > Transfer Rate out of allowed bounds!\n"); + setColor(TXTCOLOR_GREY); #endif // PRINT - } + } - return channel; + return channel; } +Testbench *create_testbench() { return create_testbench(NO_NAME); } - - -Testbench* create_testbench() { - return create_testbench(NO_NAME); -} - -Testbench* create_testbench(char* name) { - Testbench* testbench = new Testbench(name); +Testbench *create_testbench(std::string name) { + Testbench *testbench = new Testbench(name); #ifdef PRINT - printf(" > "); - rlutil::setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", testbench->get_name()); - rlutil::setColor(TXTCOLOR_GREY); - printf("(id: %03u) ", testbench->get_id()); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("created\n"); - rlutil::setColor(TXTCOLOR_GREY); + printf(" > "); + rlutil::setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", testbench->get_name().c_str()); + rlutil::setColor(TXTCOLOR_GREY); + printf("(id: %03u) ", testbench->get_id()); + rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("created\n"); + rlutil::setColor(TXTCOLOR_GREY); #endif // PRINT - testbench->init_testbench(); - return testbench; + testbench->init_testbench(); + return testbench; } /* Lookuptable create_lookuptable() { - Lookuptable lut; - - printf(" > "); - rlutil::setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", lut.get_name()); - rlutil::setColor(TXTCOLOR_GREY); - printf("(id: %03u) ", lut.get_id()); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("created\n"); - rlutil::setColor(TXTCOLOR_GREY); - - return lut; + Lookuptable lut; + + printf(" > "); + rlutil::setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", lut.get_name()); + rlutil::setColor(TXTCOLOR_GREY); + printf("(id: %03u) ", lut.get_id()); + rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("created\n"); + rlutil::setColor(TXTCOLOR_GREY); + + return lut; } Lookuptable create_lookuptable(char* name) { - Lookuptable lut(name); - - printf(" > "); - rlutil::setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", lut.get_name()); - rlutil::setColor(TXTCOLOR_GREY); - printf("(id: %03u) ", lut.get_id()); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("created\n"); - rlutil::setColor(TXTCOLOR_GREY); - - return lut; + Lookuptable lut(name); + + printf(" > "); + rlutil::setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", lut.get_name()); + rlutil::setColor(TXTCOLOR_GREY); + printf("(id: %03u) ", lut.get_id()); + rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("created\n"); + rlutil::setColor(TXTCOLOR_GREY); + + return lut; } void print_confidence_validator(Confidence_Validator conf_valid) { - printf(" > "); - rlutil::setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", conf_valid.get_name()); - rlutil::setColor(TXTCOLOR_GREY); - printf("(id: %03u) ", conf_valid.get_id()); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("created\n"); - rlutil::setColor(TXTCOLOR_GREY); - - printf(" - range of validity "); - if(conf_valid.get_flag_lower_bound_exist()) - printf("[ %.3f, ", conf_valid.get_lower_bound()); - else - printf("] -inf, "); - if(conf_valid.get_flag_upper_bound_exist()) - printf("%.3f ] ", conf_valid.get_upper_bound()); - else - printf("+inf [ "); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("set\n"); - rlutil::setColor(TXTCOLOR_GREY); - - if(conf_valid.get_flag_rates_of_change_exist()) { - printf(" - validity for rates of change of "); - printf("%.3f ", conf_valid.get_rates_of_change()); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("set\n"); - rlutil::setColor(TXTCOLOR_GREY); - } + printf(" > "); + rlutil::setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", conf_valid.get_name()); + rlutil::setColor(TXTCOLOR_GREY); + printf("(id: %03u) ", conf_valid.get_id()); + rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("created\n"); + rlutil::setColor(TXTCOLOR_GREY); + + printf(" - range of validity "); + if(conf_valid.get_flag_lower_bound_exist()) + printf("[ %.3f, ", conf_valid.get_lower_bound()); + else + printf("] -inf, "); + if(conf_valid.get_flag_upper_bound_exist()) + printf("%.3f ] ", conf_valid.get_upper_bound()); + else + printf("+inf [ "); + rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("set\n"); + rlutil::setColor(TXTCOLOR_GREY); + + if(conf_valid.get_flag_rates_of_change_exist()) { + printf(" - validity for rates of change of "); + printf("%.3f ", conf_valid.get_rates_of_change()); + rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("set\n"); + rlutil::setColor(TXTCOLOR_GREY); + } } -Confidence_Validator create_confidence_validator(float lower_bound, bool flag_lower_bound_exist, float upper_bound, bool flag_upper_bound_exist, float rates_of_change, bool flag_rates_of_change_exist) { - Confidence_Validator conf_valid(lower_bound, flag_lower_bound_exist, upper_bound, flag_upper_bound_exist, rates_of_change, flag_rates_of_change_exist); - print_confidence_validator(conf_valid); +Confidence_Validator create_confidence_validator(float lower_bound, bool +flag_lower_bound_exist, float upper_bound, bool flag_upper_bound_exist, float +rates_of_change, bool flag_rates_of_change_exist) { Confidence_Validator +conf_valid(lower_bound, flag_lower_bound_exist, upper_bound, +flag_upper_bound_exist, rates_of_change, flag_rates_of_change_exist); + print_confidence_validator(conf_valid); - return conf_valid; + return conf_valid; } -Confidence_Validator create_confidence_validator(char* name, float lower_bound, bool flag_lower_bound_exist, float upper_bound, bool flag_upper_bound_exist, float rates_of_change, bool flag_rates_of_change_exist) { - Confidence_Validator conf_valid(name, lower_bound, flag_lower_bound_exist, upper_bound, flag_upper_bound_exist, rates_of_change, flag_rates_of_change_exist); - print_confidence_validator(conf_valid); +Confidence_Validator create_confidence_validator(char* name, float lower_bound, +bool flag_lower_bound_exist, float upper_bound, bool flag_upper_bound_exist, +float rates_of_change, bool flag_rates_of_change_exist) { Confidence_Validator +conf_valid(name, lower_bound, flag_lower_bound_exist, upper_bound, +flag_upper_bound_exist, rates_of_change, flag_rates_of_change_exist); + print_confidence_validator(conf_valid); - return conf_valid; + return conf_valid; } void print_abstraction_module(Abstraction abstraction) { - printf(" > "); - rlutil::setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", abstraction.get_name()); - rlutil::setColor(TXTCOLOR_GREY); - printf("(id: %03u) ", abstraction.get_id()); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("created\n"); - rlutil::setColor(TXTCOLOR_GREY); - - //TODO: abstraction method printen - printf(" - abstraction method %u ", abstraction.get_abstraction_method()); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("set\n"); - rlutil::setColor(TXTCOLOR_GREY); - - //TODO: auch das hier bissl sch�ner machen - if(abstraction.get_flag_lookuptable_exist(0)) { - printf(" - position 0 connected mit Look up Table "); - rlutil::setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", abstraction.get_lookuptable(0)->get_name()); - rlutil::setColor(TXTCOLOR_GREY); - printf("(id: %03u) ", abstraction.get_lookuptable(0)->get_id()); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("set\n"); - rlutil::setColor(TXTCOLOR_GREY); - } -} - -Abstraction create_abstraction_module(Lookuptable* lut, unsigned int abstraction_method) { - Abstraction abstraction(lut, abstraction_method); - print_abstraction_module(abstraction); - - return abstraction; + printf(" > "); + rlutil::setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", abstraction.get_name()); + rlutil::setColor(TXTCOLOR_GREY); + printf("(id: %03u) ", abstraction.get_id()); + rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("created\n"); + rlutil::setColor(TXTCOLOR_GREY); + + //TODO: abstraction method printen + printf(" - abstraction method %u ", +abstraction.get_abstraction_method()); rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("set\n"); + rlutil::setColor(TXTCOLOR_GREY); + + //TODO: auch das hier bissl sch�ner machen + if(abstraction.get_flag_lookuptable_exist(0)) { + printf(" - position 0 connected mit Look up Table "); + rlutil::setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", abstraction.get_lookuptable(0)->get_name()); + rlutil::setColor(TXTCOLOR_GREY); + printf("(id: %03u) ", abstraction.get_lookuptable(0)->get_id()); + rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("set\n"); + rlutil::setColor(TXTCOLOR_GREY); + } +} + +Abstraction create_abstraction_module(Lookuptable* lut, unsigned int +abstraction_method) { Abstraction abstraction(lut, abstraction_method); + print_abstraction_module(abstraction); + + return abstraction; } -Abstraction create_abstraction_module(char* name, Lookuptable* lut, unsigned int abstraction_method) { - Abstraction abstraction(name, lut, abstraction_method); - print_abstraction_module(abstraction); +Abstraction create_abstraction_module(char* name, Lookuptable* lut, unsigned int +abstraction_method) { Abstraction abstraction(name, lut, abstraction_method); + print_abstraction_module(abstraction); - return abstraction; + return abstraction; } void print_bunch_module(Bunch_Module bunch_module) { - printf(" > "); - rlutil::setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", bunch_module.get_name()); - rlutil::setColor(TXTCOLOR_GREY); - printf("(id: %03u) ", bunch_module.get_id()); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("created\n"); - rlutil::setColor(TXTCOLOR_GREY); - - //TODO: abstraction method printen - printf(" - abstraction method %u ", bunch_module.get_bunch_method()); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("set\n"); - rlutil::setColor(TXTCOLOR_GREY); -} + printf(" > "); + rlutil::setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", bunch_module.get_name()); + rlutil::setColor(TXTCOLOR_GREY); + printf("(id: %03u) ", bunch_module.get_id()); + rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("created\n"); + rlutil::setColor(TXTCOLOR_GREY); + + //TODO: abstraction method printen + printf(" - abstraction method %u ", bunch_module.get_bunch_method()); + rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("set\n"); + rlutil::setColor(TXTCOLOR_GREY); +} Bunch_Module create_bunch_module(unsigned int bunch_method) { - Bunch_Module bunch_module(bunch_method); - print_bunch_module(bunch_module); + Bunch_Module bunch_module(bunch_method); + print_bunch_module(bunch_module); - return bunch_module; + return bunch_module; } Bunch_Module create_bunch_module(char* name, unsigned int bunch_method) { - Bunch_Module bunch_module(name, bunch_method); - print_bunch_module(bunch_module); + Bunch_Module bunch_module(name, bunch_method); + print_bunch_module(bunch_module); - return bunch_module; + return bunch_module; } */ -FILE* make_file_pointer(const char* filepath, int mode) { - - FILE* fpointer = nullptr; - - if(mode == CSV_MODE_READ) { - // file_opened = fopen_s(&fpointer, filepath, "r"); //only windows compatible - fpointer = fopen(filepath, "r"); - } - else if(mode == CSV_MODE_WRITE) { - // file_opened = fopen_s(&fpointer, filepath, "w"); //only windows compatible - fpointer = fopen(filepath, "w"); - } - else { +FILE *make_file_pointer(const char *filepath, int mode) { + + bool file_opened; + FILE *fpointer = nullptr; + + if (mode == CSV_MODE_READ) { +#ifdef _WIN32 + file_opened = fopen_s(&fpointer, filepath, "r"); // only windows compatible +#else + fpointer = fopen(filepath, "r"); +#endif + } else if (mode == CSV_MODE_WRITE) { +#ifdef _WIN32 + file_opened = fopen_s(&fpointer, filepath, "w"); // only windows compatible +#else + fpointer = fopen(filepath, "w"); +#endif + } else { #ifdef PRINT - printf("File pointer mode for \"%s\" ", filepath); - rlutil::setColor(TXTCOLOR_LIGHTRED); - printf("is not supported!\n"); - rlutil::setColor(TXTCOLOR_GREY); + printf("File pointer mode for \"%s\" ", filepath); + rlutil::setColor(TXTCOLOR_LIGHTRED); + printf("is not supported!\n"); + rlutil::setColor(TXTCOLOR_GREY); #endif // PRINT - return NULL; - } + return NULL; + } - //if(file_opened == 0) { - if(fpointer != nullptr) { - return fpointer; - } + // if(file_opened == 0) { + if (fpointer != nullptr && file_opened == 0) { + return fpointer; + } #ifdef PRINT - printf("File pointer \"%s\" ", filepath); - rlutil::setColor(TXTCOLOR_LIGHTRED); - printf("could not created!\n"); - rlutil::setColor(TXTCOLOR_GREY); + printf("File pointer \"%s\" ", filepath); + rlutil::setColor(TXTCOLOR_LIGHTRED); + printf("could not created!\n"); + rlutil::setColor(TXTCOLOR_GREY); #endif // PRINT - return NULL; + return NULL; } -void print_csv_reader(CSVreaderModule* csvReaderModule,const char* filepath) { - printf(" > "); - rlutil::setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", csvReaderModule->get_name()); - rlutil::setColor(TXTCOLOR_GREY); - printf("(id: %03u) for \"%s\" ", csvReaderModule->get_id(), filepath); - rlutil::setColor(TXTCOLOR_LIGHTGREEN); - printf("created\n"); - rlutil::setColor(TXTCOLOR_GREY); -} - -CSVreaderModule* create_CSVreaderModule(const char* filepath, unsigned int column, unsigned int start_row) { - - FILE* fpointer = make_file_pointer(filepath, CSV_MODE_READ); - - if(fpointer) { - CSVreaderModule* csvr = new CSVreaderModule(fpointer, column, start_row); - print_csv_reader(csvr, filepath); - - return csvr; - } - else { - CSVreaderModule* csvr = new CSVreaderModule(); - - return csvr; - } +void print_csv_reader(CSVreaderModule *csvReaderModule, const char *filepath) { + printf(" > "); + rlutil::setColor(TXTCOLOR_LIGHTCYAN); + printf("%s ", csvReaderModule->get_name().c_str()); + rlutil::setColor(TXTCOLOR_GREY); + printf("(id: %03u) for \"%s\" ", csvReaderModule->get_id(), filepath); + rlutil::setColor(TXTCOLOR_LIGHTGREEN); + printf("created\n"); + rlutil::setColor(TXTCOLOR_GREY); } -CSVreaderModule* create_CSVreaderModule(char* name,const char* filepath, unsigned int column, unsigned int start_row) { - - FILE* fpointer = make_file_pointer(filepath, CSV_MODE_READ); +CSVreaderModule *create_CSVreaderModule(const char *filepath, + unsigned int column, + unsigned int start_row) { - if(fpointer) { - CSVreaderModule* csvr = new CSVreaderModule(name, fpointer, column, start_row); -#ifdef PRINT - print_csv_reader(csvr, filepath); -#endif // PRINT - return csvr; - } - else { - CSVreaderModule* csvr = new CSVreaderModule; + FILE *fpointer = make_file_pointer(filepath, CSV_MODE_READ); - return csvr; - } + if (fpointer) { + CSVreaderModule *csvr = new CSVreaderModule(fpointer, column, start_row); + print_csv_reader(csvr, filepath); + + return csvr; + } else { + CSVreaderModule *csvr = new CSVreaderModule(); + + return csvr; + } } +CSVreaderModule *create_CSVreaderModule(std::string name, const char *filepath, + unsigned int column, + unsigned int start_row) { + + FILE *fpointer = make_file_pointer(filepath, CSV_MODE_READ); + + if (fpointer == NULL) { + printf("DA IS DER HUND\n"); + } else { + printf("ALLES GUT\n"); + } -StateHandler create_stateHandler() { - return create_stateHandler(NO_NAME); + if (fpointer) { + CSVreaderModule *csvr = + new CSVreaderModule(name, fpointer, column, start_row); +#ifdef PRINT + print_csv_reader(csvr, filepath); +#endif // PRINT + return csvr; + } else { + CSVreaderModule *csvr = new CSVreaderModule; + + return csvr; + } } -StateHandler create_stateHandler(char* name) { - StateHandler stateHandler(name); - return stateHandler; +StateHandler create_stateHandler() { return create_stateHandler(NO_NAME); } + +StateHandler create_stateHandler(std::string name) { + StateHandler stateHandler(name); + return stateHandler; } diff --git a/Version_Max_07_05_2018_CMake/src/create_unit.h b/Version_Max_07_05_2018_CMake/src/create_unit.h index c9934e8..daeeadb 100755 --- a/Version_Max_07_05_2018_CMake/src/create_unit.h +++ b/Version_Max_07_05_2018_CMake/src/create_unit.h @@ -1,62 +1,64 @@ #ifndef CREATE_UNIT_HEADERFILE #define CREATE_UNIT_HEADERFILE #include #include "Agent.h" #include "CSVreaderModule.h" #include "HistoryModule.h" #include "Sensor.h" #include "Testbench.h" +#include + /* #include "Testbench.h" #include "Lookuptable.h" #include "ConfidenceModule.h" #include "Bunch_Module.h" */ #define CSV_MODE_READ 0 #define CSV_MODE_WRITE 1 Agent* create_agent(); -Agent* create_agent(char* name); +Agent* create_agent(std::string name); /* Agent create_agent(unsigned int abstraction_method); Agent create_agent(char* name, unsigned int abstraction_method); */ Sensor* create_sensor(); -Sensor* create_sensor(char* name); +Sensor* create_sensor(std::string name); HistoryModule create_historyModule(unsigned int history_length, int delimitation_mode); -HistoryModule create_historyModule(char* name, unsigned int history_length, int delimitation_mode); +HistoryModule create_historyModule(std::string name, unsigned int history_length, int delimitation_mode); Channel* create_channel(unsigned int transfer_rate); -Channel* create_channel(char* name, unsigned int transfer_rate); +Channel* create_channel(std::string, unsigned int transfer_rate); Testbench* create_testbench(); -Testbench* create_testbench(char* name); +Testbench* create_testbench(std::string name); /* Lookuptable create_lookuptable(); Lookuptable create_lookuptable(char* name); ConfidenceModule create_confidence_validator(float lower_bound, bool flag_lower_bound_exist, float upper_bound, bool flag_upper_bound_exist, float rates_of_change, bool flag_rates_of_change_exist); ConfidenceModule create_confidence_validator(char* name, float lower_bound, bool flag_lower_bound_exist, float upper_bound, bool flag_upper_bound_exist, float rates_of_change, bool flag_rates_of_change_exist); AbstractionModule create_abstraction_module(Lookuptable* lut, unsigned int abstraction_method); AbstractionModule create_abstraction_module(char* name, Lookuptable* lut, unsigned int abstraction_method); Bunch_Module create_bunch_module(unsigned int bunch_method); Bunch_Module create_bunch_module(char* name, unsigned int bunch_method); */ CSVreaderModule* create_CSVreaderModule(const char* filepath, unsigned int column, unsigned int start_row); -CSVreaderModule* create_CSVreaderModule(char* name,const char* filepath, unsigned int column, unsigned int start_row); +CSVreaderModule* create_CSVreaderModule(std::string name,const char* filepath, unsigned int column, unsigned int start_row); StateHandler create_stateHandler(); -StateHandler create_stateHandler(char* name); +StateHandler create_stateHandler(std::string name); #endif diff --git a/Version_Max_07_05_2018_CMake/src/csvparser.c b/Version_Max_07_05_2018_CMake/src/csvparser.c deleted file mode 100755 index 4be5c91..0000000 --- a/Version_Max_07_05_2018_CMake/src/csvparser.c +++ /dev/null @@ -1,239 +0,0 @@ -#include -#include -#include -#include - -#include "csvparser.h" - -#ifdef __cplusplus -extern "C" { -#endif - -CsvParser *CsvParser_new(const char *filePath, const char *delimiter, int firstLineIsHeader) { - CsvParser *csvParser = (CsvParser*)malloc(sizeof(CsvParser)); - if (filePath == NULL) { - csvParser->filePath_ = NULL; - } else { - int filePathLen = strlen(filePath); - csvParser->filePath_ = (char*)malloc((filePathLen + 1)); - strcpy(csvParser->filePath_, filePath); - } - csvParser->firstLineIsHeader_ = firstLineIsHeader; - csvParser->errMsg_ = NULL; - if (delimiter == NULL) { - csvParser->delimiter_ = ','; - } else if (_CsvParser_delimiterIsAccepted(delimiter)) { - csvParser->delimiter_ = *delimiter; - } else { - csvParser->delimiter_ = '\0'; - } - csvParser->header_ = NULL; - csvParser->fileHandler_ = NULL; - csvParser->fromString_ = 0; - csvParser->csvString_ = NULL; - csvParser->csvStringIter_ = 0; - - return csvParser; -} - -CsvParser *CsvParser_new_from_string(const char *csvString, const char *delimiter, int firstLineIsHeader) { - CsvParser *csvParser = CsvParser_new(NULL, delimiter, firstLineIsHeader); - csvParser->fromString_ = 1; - if (csvString != NULL) { - int csvStringLen = strlen(csvString); - csvParser->csvString_ = (char*)malloc(csvStringLen + 1); - strcpy(csvParser->csvString_, csvString); - } - return csvParser; -} - -void CsvParser_destroy(CsvParser *csvParser) { - if (csvParser == NULL) { - return; - } - if (csvParser->filePath_ != NULL) { - free(csvParser->filePath_); - } - if (csvParser->errMsg_ != NULL) { - free(csvParser->errMsg_); - } - if (csvParser->fileHandler_ != NULL) { - fclose(csvParser->fileHandler_); - } - if (csvParser->header_ != NULL) { - CsvParser_destroy_row(csvParser->header_); - } - if (csvParser->csvString_ != NULL) { - free(csvParser->csvString_); - } - free(csvParser); -} - -void CsvParser_destroy_row(CsvRow *csvRow) { - int i; - for (i = 0 ; i < csvRow->numOfFields_ ; i++) { - free(csvRow->fields_[i]); - } - free(csvRow->fields_); - free(csvRow); -} - -CsvRow *CsvParser_getHeader(CsvParser *csvParser) { - if (! csvParser->firstLineIsHeader_) { - _CsvParser_setErrorMessage(csvParser, "Cannot supply header, as current CsvParser object does not support header"); - return NULL; - } - if (csvParser->header_ == NULL) { - csvParser->header_ = _CsvParser_getRow(csvParser); - } - return csvParser->header_; -} - -CsvRow *CsvParser_getRow(CsvParser *csvParser) { - if (csvParser->firstLineIsHeader_ && csvParser->header_ == NULL) { - csvParser->header_ = _CsvParser_getRow(csvParser); - } - return _CsvParser_getRow(csvParser); -} - -int CsvParser_getNumFields(CsvRow *csvRow) { - return csvRow->numOfFields_; -} - -const char **CsvParser_getFields(CsvRow *csvRow) { - return (const char**)csvRow->fields_; -} - -CsvRow *_CsvParser_getRow(CsvParser *csvParser) { - int numRowRealloc = 0; - int acceptedFields = 64; - int acceptedCharsInField = 64; - if (csvParser->filePath_ == NULL && (! csvParser->fromString_)) { - _CsvParser_setErrorMessage(csvParser, "Supplied CSV file path is NULL"); - return NULL; - } - if (csvParser->csvString_ == NULL && csvParser->fromString_) { - _CsvParser_setErrorMessage(csvParser, "Supplied CSV string is NULL"); - return NULL; - } - if (csvParser->delimiter_ == '\0') { - _CsvParser_setErrorMessage(csvParser, "Supplied delimiter is not supported"); - return NULL; - } - if (! csvParser->fromString_) { - if (csvParser->fileHandler_ == NULL) { - csvParser->fileHandler_ = fopen(csvParser->filePath_, "r"); - if (csvParser->fileHandler_ == NULL) { - int errorNum = errno; - const char *errStr = strerror(errorNum); - char *errMsg = (char*)malloc(1024 + strlen(errStr)); - strcpy(errMsg, ""); - sprintf(errMsg, "Error opening CSV file for reading: %s : %s", csvParser->filePath_, errStr); - _CsvParser_setErrorMessage(csvParser, errMsg); - free(errMsg); - return NULL; - } - } - } - CsvRow *csvRow = (CsvRow*)malloc(sizeof(CsvRow)); - csvRow->fields_ = (char**)malloc(acceptedFields * sizeof(char*)); - csvRow->numOfFields_ = 0; - int fieldIter = 0; - char *currField = (char*)malloc(acceptedCharsInField); - int inside_complex_field = 0; - int currFieldCharIter = 0; - int seriesOfQuotesLength = 0; - int lastCharIsQuote = 0; - int isEndOfFile = 0; - while (1) { - char currChar = (csvParser->fromString_) ? csvParser->csvString_[csvParser->csvStringIter_] : fgetc(csvParser->fileHandler_); - csvParser->csvStringIter_++; - int endOfFileIndicator; - if (csvParser->fromString_) { - endOfFileIndicator = (currChar == '\0'); - } else { - endOfFileIndicator = feof(csvParser->fileHandler_); - } - if (endOfFileIndicator) { - if (currFieldCharIter == 0 && fieldIter == 0) { - _CsvParser_setErrorMessage(csvParser, "Reached EOF"); - free(currField); - CsvParser_destroy_row(csvRow); - return NULL; - } - currChar = '\n'; - isEndOfFile = 1; - } - if (currChar == '\r') { - continue; - } - if (currFieldCharIter == 0 && ! lastCharIsQuote) { - if (currChar == '\"') { - inside_complex_field = 1; - lastCharIsQuote = 1; - continue; - } - } else if (currChar == '\"') { - seriesOfQuotesLength++; - inside_complex_field = (seriesOfQuotesLength % 2 == 0); - if (inside_complex_field) { - currFieldCharIter--; - } - } else { - seriesOfQuotesLength = 0; - } - if (isEndOfFile || ((currChar == csvParser->delimiter_ || currChar == '\n') && ! inside_complex_field) ){ - currField[lastCharIsQuote ? currFieldCharIter - 1 : currFieldCharIter] = '\0'; - csvRow->fields_[fieldIter] = (char*)malloc(currFieldCharIter + 1); - strcpy(csvRow->fields_[fieldIter], currField); - free(currField); - csvRow->numOfFields_++; - if (currChar == '\n') { - return csvRow; - } - if (csvRow->numOfFields_ != 0 && csvRow->numOfFields_ % acceptedFields == 0) { - csvRow->fields_ = (char**)realloc(csvRow->fields_, ((numRowRealloc + 2) * acceptedFields) * sizeof(char*)); - numRowRealloc++; - } - acceptedCharsInField = 64; - currField = (char*)malloc(acceptedCharsInField); - currFieldCharIter = 0; - fieldIter++; - inside_complex_field = 0; - } else { - currField[currFieldCharIter] = currChar; - currFieldCharIter++; - if (currFieldCharIter == acceptedCharsInField - 1) { - acceptedCharsInField *= 2; - currField = (char*)realloc(currField, acceptedCharsInField); - } - } - lastCharIsQuote = (currChar == '\"') ? 1 : 0; - } -} - -int _CsvParser_delimiterIsAccepted(const char *delimiter) { - char actualDelimiter = *delimiter; - if (actualDelimiter == '\n' || actualDelimiter == '\r' || actualDelimiter == '\0' || - actualDelimiter == '\"') { - return 0; - } - return 1; -} - -void _CsvParser_setErrorMessage(CsvParser *csvParser, const char *errorMessage) { - if (csvParser->errMsg_ != NULL) { - free(csvParser->errMsg_); - } - int errMsgLen = strlen(errorMessage); - csvParser->errMsg_ = (char*)malloc(errMsgLen + 1); - strcpy(csvParser->errMsg_, errorMessage); -} - -const char *CsvParser_getErrorMessage(CsvParser *csvParser) { - return csvParser->errMsg_; -} - -#ifdef __cplusplus -} -#endif diff --git a/Version_Max_07_05_2018_CMake/src/csvparser.h b/Version_Max_07_05_2018_CMake/src/csvparser.h deleted file mode 100755 index 9d08966..0000000 --- a/Version_Max_07_05_2018_CMake/src/csvparser.h +++ /dev/null @@ -1,52 +0,0 @@ -#ifndef CSVPARSER_H -#define CSVPARSER_H - -#include - -#define _CRT_SECURE_NO_WARNINGS - - - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct CsvRow { - char **fields_; - int numOfFields_; -} CsvRow; - -typedef struct CsvParser { - char *filePath_; - char delimiter_; - int firstLineIsHeader_; - char *errMsg_; - CsvRow *header_; - FILE *fileHandler_; - int fromString_; - char *csvString_; - int csvStringIter_; -} CsvParser; - - -// Public -CsvParser *CsvParser_new(const char *filePath, const char *delimiter, int firstLineIsHeader); -CsvParser *CsvParser_new_from_string(const char *csvString, const char *delimiter, int firstLineIsHeader); -void CsvParser_destroy(CsvParser *csvParser); -void CsvParser_destroy_row(CsvRow *csvRow); -CsvRow *CsvParser_getHeader(CsvParser *csvParser); -CsvRow *CsvParser_getRow(CsvParser *csvParser); -int CsvParser_getNumFields(CsvRow *csvRow); -const char **CsvParser_getFields(CsvRow *csvRow); -const char* CsvParser_getErrorMessage(CsvParser *csvParser); - -// Private -CsvRow *_CsvParser_getRow(CsvParser *csvParser); -int _CsvParser_delimiterIsAccepted(const char *delimiter); -void _CsvParser_setErrorMessage(CsvParser *csvParser, const char *errorMessage); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/Version_Max_07_05_2018_CMake/src/inAgentsRegistrations.cpp b/Version_Max_07_05_2018_CMake/src/inAgentsRegistrations.cpp index ccad09b..ab19d98 100755 --- a/Version_Max_07_05_2018_CMake/src/inAgentsRegistrations.cpp +++ b/Version_Max_07_05_2018_CMake/src/inAgentsRegistrations.cpp @@ -1,105 +1,105 @@ #include "inAgentsRegistrations.h" #include "rlutil.h" #define PRINT using namespace rlutil; bool registerSlaveAgentAsInputVariableInStateHandler(Agent* masteragent, Channel* channel) { - if(masteragent != NULL, channel != NULL) { + if(masteragent != NULL || channel != NULL) { SlaveAgentSlotOfAgent* slot = masteragent->get_slaveAgentHandlerOfAgent()->get_slaveAgentSlotAddress(channel); if(slot != NULL) { if(masteragent->get_stateHandler()->addInputVariable(slot)){ #ifdef PRINT printf(" > Channel "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", channel->get_name()); + printf("%s ", channel->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) ", channel->get_id()); setColor(TXTCOLOR_LIGHTGREEN); printf("registered "); setColor(TXTCOLOR_GREY); printf("as "); setColor(TXTCOLOR_LIGHTGREEN); printf("Input Variable "); setColor(TXTCOLOR_GREY); printf("in stateHandler of "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", masteragent->get_name()); + printf("%s ", masteragent->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", masteragent->get_id()); #endif // PRINT return true; } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf(" > Channel %s (id: %03u) is not connected to Agent %s (id: %03u)\n", channel->get_name(), channel->get_id(), masteragent->get_name(), masteragent->get_id()); + printf(" > Channel %s (id: %03u) is not connected to Agent %s (id: %03u)\n", channel->get_name().c_str(), channel->get_id(), masteragent->get_name().c_str(), masteragent->get_id()); #endif // PRINT } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf(" > Channel %s (id: %03u) is not connected to Agent %s (id: %03u)\n", channel->get_name(), channel->get_id(), masteragent->get_name(), masteragent->get_id()); + printf(" > Channel %s (id: %03u) is not connected to Agent %s (id: %03u)\n", channel->get_name().c_str(), channel->get_id(), masteragent->get_name().c_str(), masteragent->get_id()); #endif // PRINT } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf(" > Agent or Channel is not valid\n"); #endif // PRINT } return false; } bool registerSlaveAgentAsOutputVariableInStateHandler(Agent* masteragent, Channel* channel) { - if (masteragent != NULL, channel != NULL) { + if (masteragent != NULL || channel != NULL) { SlaveAgentSlotOfAgent* slot = masteragent->get_slaveAgentHandlerOfAgent()->get_slaveAgentSlotAddress(channel); if (slot != NULL) { if (masteragent->get_stateHandler()->addOutputVariable(slot)) { #ifdef PRINT printf(" > Channel "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", channel->get_name()); + printf("%s ", channel->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) ", channel->get_id()); setColor(TXTCOLOR_LIGHTGREEN); printf("registered "); setColor(TXTCOLOR_GREY); printf("as "); setColor(TXTCOLOR_LIGHTGREEN); printf("Output Variable "); setColor(TXTCOLOR_GREY); printf("in stateHandler of "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", masteragent->get_name()); + printf("%s ", masteragent->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", masteragent->get_id()); #endif // PRINT return true; } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf(" > Channel %s (id: %03u) is not connected to Agent %s (id: %03u)\n", channel->get_name(), channel->get_id(), masteragent->get_name(), masteragent->get_id()); + printf(" > Channel %s (id: %03u) is not connected to Agent %s (id: %03u)\n", channel->get_name().c_str(), channel->get_id(), masteragent->get_name().c_str(), masteragent->get_id()); #endif // PRINT } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf(" > Channel %s (id: %03u) is not connected to Agent %s (id: %03u)\n", channel->get_name(), channel->get_id(), masteragent->get_name(), masteragent->get_id()); + printf(" > Channel %s (id: %03u) is not connected to Agent %s (id: %03u)\n", channel->get_name().c_str(), channel->get_id(), masteragent->get_name().c_str(), masteragent->get_id()); #endif // PRINT } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf(" > Agent or Channel is not valid\n"); #endif // PRINT } return false; } \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/main.cpp b/Version_Max_07_05_2018_CMake/src/main.cpp index f3045be..704c00a 100755 --- a/Version_Max_07_05_2018_CMake/src/main.cpp +++ b/Version_Max_07_05_2018_CMake/src/main.cpp @@ -1,1128 +1,112 @@ -/* - * main.cpp - * - * Created on: 25.05.2018 - * Author: edwin willegger, edwin.willegger@tuwien.ac.at - * This file is used to generate output data from measurements - * from OMV for SAVE project. - * In this case the data of the 18.12.2017 is analyzed. - * Based on the implementation of Maximilian Götzinger. - */ - -#include "Agent.h" -#include "Channel.h" -#include "create_unit.h" -#include "CSVreaderModule.h" -#include "inAgentsRegistrations.h" -#include "mount_nodes.h" -#include "register_in_testbench.h" -#include "Sensor.h" -#include "setupNode.h" #include -#include -#include -#include -#include -#include "Testbench.h" -#include "file_util.h" - -#include "LinearFunction.h" -#include "LinearFunctionBlock.h" - -#include "Testbench_Config.h" - -using namespace std; - -/********************************************************************************************************************** - ************************************************begin of global definitions of variables and constants *************** - **********************************************************************************************************************/ - -//every n-th SAMBLING value will be read in from the CSV-Data-Input-Files. -#define SAMPLING 1 - -//global vectors for the different elements -static vector vec_of_Agents; -static vector vec_of_Sensors; -static vector vec_of_Channels_for_Sensors; -static vector vec_of_Channels_for_Agents; -static vector vec_of_linear_Function_Blocks; -static vector vec_of_test_benches; -static vector vec_of_csv_readers; - -//names of the measured data -const string FIRST_MEASURED_DATA_NAME = "FC6504_Y"; //Input -const string SECOND_MEASURED_DATA_NAME = "FC6504"; //Output -const string THIRD_MEASURED_DATA_NAME = "FC6504_SP"; //Input -const string FOURTH_MEASURED_DATA_NAME = "PI6584"; //Input - - -//viability monitor -const string VIABILITY_MONITOR = "ViabilityMonitor"; -//index number of output -const int INDEX_OUTPUT = 1; - -//name for the channels of the sensors and agents -const string APPENDIX_FOR_CHANNEL_SENSOR_NAME = "(SA)"; -const string FIRST_MEASURED_CHANNEL_SENSOR_NAME = FIRST_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; -const string SECOND_MEASURED_CHANNEL_SENSOR_NAME = SECOND_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; -const string THIRD_MEASURED_CHANNEL_SENSOR_NAME = THIRD_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; -const string FOURTH_MEASURED_CHANNEL_SENSOR_NAME = FOURTH_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; -const string APPENDIX_FOR_CHANNEL_AGENT_NAME = "(AA-UP)"; -const string FIRST_MEASURED_CHANNEL_AGENT_NAME = FIRST_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; -const string SECOND_MEASURED_CHANNEL_AGENT_NAME = SECOND_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; -const string THIRD_MEASURED_CHANNEL_AGENT_NAME = THIRD_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; -const string FOURTH_MEASURED_CHANNEL_AGENT_NAME = FOURTH_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; - -#define TRANSFER_RATE_CHANNEL_SENSOR 0 -#define TRANSFER_RATE_CHANNEL_AGENT MAX_BUFFER_LENGTH - - -////////////////////////////////////////////// -/* -//out of the outer_bound the function is 0 or 1 and within 1 or 0 depending on function or complementery. - inner_bound_xxx = /----------=1----|------=1---------\ = inner_bound_xxxx - outer_bound_xxx = / | \ - / | \ - 0=__________/ | \ = outer_bound_xxxx ______ = 0 --------------------------------------------------------------------------- -*/ - -//parameters of boundary for similar function -#define OUTTER_BOUND_SIM_DIF 0.20 //outer bound e. g. 0.14 = 14 percent; testested with 0.20, 0.14, 0.06, -#define INNER_BOUND_SIM_DIF 0.01 //inner bound e. g. 0.01 = 1 percent - -//same way as above but shows drift. -#define OUTTER_BOUND_DRIFT OUTTER_BOUND_SIM_DIF * 3 -#define INNER_BOUND_DRIFT OUTTER_BOUND_SIM_DIF - -//timer sagt, dass nach dem DOWNSAMPLING der Ausgang bis zu -//n Werte später sich ändern darf, nachdem Sich der Eingang geändert hat. -#define BOUND_BROKEN 2 - -//length where fuzzy function raises from 0 to 1 or 1 to 0 for the complementery. -//history of the data depends of it, and should change, if it changes. -#define LENGTH 10 - - -//definitions for the testbench -const string TEST_BENCH = "testbench"; - -//defintions for the csv-reader-modules -const string APPENDIX_CSV_MODULES = " CSV-Reader"; -const string FIRST_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; -const string SECOND_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; -const string THIRD_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; -const string FOURTH_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; - - -//to switch between different file configurations change the -//DEFINES in file_util.h - -/********************************************************************************************************************** - ************************************************end of global definitions of variables and constants ***************** - **********************************************************************************************************************/ - -/********************************************************************************************************************** - ************************************************begin of function prototypes ***************************************** - **********************************************************************************************************************/ -void create_and_register_all_Testbench_Configs(Testbench* current_tb); - -void create_and_register_All_Agents(); -void set_working_cycle_of_All_Agents(); - -void create_and_register_All_Sensors(); -void set_working_cycle_of_All_Sensors(); - -void create_and_register_channels(); -void create_and_register_channels_for_sensors(); -void create_and_register_channels_for_agents(); - -void mount_sensors_in_agents(); -void mount_agents_in_agents(); - -void register_data_agents_in_agent_state_Handler(); - -void create_linear_function_blocks(); -void create_same_state_deviation_function_block(); -void create_another_state_deviation_function_block(); -void create_state_time_function_block(); -void create_another_state_time_function_block(); -void create_valid_state_deviation_function_block(); -void create_invalid_state_deviation_function_block(); -void create_valid_state_time_function_block(); -void create_invalid_state_time_function_block(); -void create_confidence_state_drift_function_block(); -void create_confidence_broken_function_block(); -void mount_function_blocks_to_viability_monitor(); - -void create_all_testbenches(); - -void create_csvr_modules(); - -void register_agents_in_testbenches(); - -void register_sensors_in_testbenches(); - -void register_channels_in_testbenches(); -void register_channels_of_sensors_in_testbenches(); -void register_channels_of_actors_in_testbenches(); - -void set_config_values_in_linear_functions(Testbench* current_tb); -void set_parameters_LinearFunctionBlock(LinearFunctionBlock* cur_lin_func_block); -void set_parameters_LinearFunction(vector vec_Lin_Func); - -void set_CSV_Writer_parameter(Testbench* current_tb); - -void run_simulation_of_all_testbenches(); - -void close_file_pointers(); - -void empty_static_vectors(); -void empty_vec_Agent(); -void empty_vec_Channel_Agent(); -void empty_vec_Channel_Sensor(); -void empty_vec_Sensors(); -void empty_vec_csv_raders(); -void empty_vec_linear_func_Blocks(); -void empty_vec_TestBench(); - - -/********************************************************************************************************************** - ************************************************end of function prototypes ******************************************* - **********************************************************************************************************************/ - -int main() -{ - cout << "This program processes test data from OMV Steam Cracker furnaces." << endl; - - create_and_register_All_Agents(); - set_working_cycle_of_All_Agents(); - - - create_and_register_All_Sensors(); - set_working_cycle_of_All_Sensors(); - - create_and_register_channels(); - - mount_sensors_in_agents(); - - mount_agents_in_agents(); - - register_data_agents_in_agent_state_Handler(); - - create_linear_function_blocks(); - - mount_function_blocks_to_viability_monitor(); - - create_all_testbenches(); - - create_csvr_modules(); - - register_agents_in_testbenches(); - - register_sensors_in_testbenches(); - - register_channels_in_testbenches(); - - - - run_simulation_of_all_testbenches(); - - //close_file_pointers(); - //TODO memory free of all objects. - empty_static_vectors(); - - cout << "Program finished successfully" << endl; - return 0; -} - -void create_and_register_all_Testbench_Configs(Testbench* current_tb) -{ - - One_Config_t one; - one.bound_broken = 2; - one.inner_bound_sim_dif = 0.02; - one.outter_bound_sim_dif = 0.08; - one.inner_bound_drift = 3 * one.outter_bound_sim_dif; - one.inner_bound_drift = one.outter_bound_sim_dif; - one.length = 10; - Testbench_Config* cfg = new Testbench_Config(one); - cfg->print(); - current_tb->register_testbench_config(cfg); -} - - - -/* - * creates all the agents used in the measurement - * and stores them into the global vector - */ -void create_and_register_All_Agents() -{ - cout << "Creating Agents" << endl; - char* c_name_of_current_agent = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_agent, FIRST_MEASURED_DATA_NAME.c_str()); - Agent* a_FC6504_Y = create_agent(c_name_of_current_agent); - strcpy(c_name_of_current_agent, SECOND_MEASURED_DATA_NAME.c_str()); - Agent* a_FC6504 = create_agent(c_name_of_current_agent); - strcpy(c_name_of_current_agent, THIRD_MEASURED_DATA_NAME.c_str()); - Agent* a_FC6504_SP = create_agent(c_name_of_current_agent); - strcpy(c_name_of_current_agent, FOURTH_MEASURED_DATA_NAME.c_str()); - Agent* a_PI6584 = create_agent(c_name_of_current_agent); - strcpy(c_name_of_current_agent, VIABILITY_MONITOR.c_str()); - Agent* a_viabilityMonitor = create_agent(c_name_of_current_agent); - vec_of_Agents.push_back(a_FC6504_Y); - vec_of_Agents.push_back(a_FC6504); - vec_of_Agents.push_back(a_FC6504_SP); - vec_of_Agents.push_back(a_PI6584); - vec_of_Agents.push_back(a_viabilityMonitor); - cout << vec_of_Agents.size() << " agents were created" << endl; - delete c_name_of_current_agent; -} - -/* - * the working_cycle for all registered agents is set - */ -void set_working_cycle_of_All_Agents() -{ - unsigned int working_Cyle = SAMPLING; - unsigned int size_of_vec_of_Agents = 0; - unsigned int index = 0; - Agent* current_Agent; - size_of_vec_of_Agents = vec_of_Agents.size(); - for(index = 0; index < size_of_vec_of_Agents; index++) { - current_Agent = vec_of_Agents[index]; - setWorkingCycleOfAgent(current_Agent, working_Cyle); - } -} - -/* - * all necessary sensors are created and registered - */ -void create_and_register_All_Sensors() -{ - cout << "Creating Sensors" << endl; - char* c_name_of_current_sensor = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_sensor, FIRST_MEASURED_DATA_NAME.c_str()); - Sensor* s_FC6504_Y = create_sensor(c_name_of_current_sensor); - strcpy(c_name_of_current_sensor, SECOND_MEASURED_DATA_NAME.c_str()); - Sensor* s_FC6504 = create_sensor(c_name_of_current_sensor); - strcpy(c_name_of_current_sensor, THIRD_MEASURED_DATA_NAME.c_str()); - Sensor* s_FC6504_SP = create_sensor(c_name_of_current_sensor); - strcpy(c_name_of_current_sensor, FOURTH_MEASURED_DATA_NAME.c_str()); - Sensor* s_PI6584 = create_sensor(c_name_of_current_sensor); - vec_of_Sensors.push_back(s_FC6504_Y); - vec_of_Sensors.push_back(s_FC6504); - vec_of_Sensors.push_back(s_FC6504_SP); - vec_of_Sensors.push_back(s_PI6584); - cout << vec_of_Sensors.size() << " sensors were created." << endl; - delete c_name_of_current_sensor; -} - -/* - * working cycle of all registered sensors is set - */ -void set_working_cycle_of_All_Sensors() -{ - unsigned int working_Cyle = SAMPLING; - unsigned int size_of_vec_of_Sensors = 0; - unsigned int index = 0; - Sensor* current_Sensor; - - size_of_vec_of_Sensors = vec_of_Sensors.size(); - for(index = 0; index < size_of_vec_of_Sensors; index++) { - current_Sensor = vec_of_Sensors[index]; - setWorkingCycleOfSensor(current_Sensor, working_Cyle); - } -} - -/* - * creating and registering all channels - */ -void create_and_register_channels() -{ - create_and_register_channels_for_sensors(); - create_and_register_channels_for_agents(); -} - -/* - * creating and registering the channels for the sensors. - */ -void create_and_register_channels_for_sensors() -{ - cout << "Creating and registering channels for sensors" << endl; - char* c_name_of_current_channel = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_SENSOR_NAME.c_str()); - Channel* c_sa_FC6504_Y = create_channel(c_name_of_current_channel, 0); - strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_SENSOR_NAME.c_str()); - Channel* c_sa_FC6504 = create_channel(c_name_of_current_channel, 0); - strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_SENSOR_NAME.c_str()); - Channel* c_sa_FC6504_SP = create_channel(c_name_of_current_channel, 0); - strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_SENSOR_NAME.c_str()); - Channel* c_sa_PI6584 = create_channel(c_name_of_current_channel, 0); - - vec_of_Channels_for_Sensors.push_back(c_sa_FC6504_Y); - vec_of_Channels_for_Sensors.push_back(c_sa_FC6504); - vec_of_Channels_for_Sensors.push_back(c_sa_FC6504_SP); - vec_of_Channels_for_Sensors.push_back(c_sa_PI6584); - cout << vec_of_Channels_for_Sensors.size() << " channels for sensors were created" << endl; - - delete c_name_of_current_channel; -} - -/* - * creating and registering the channels for the agents - */ -void create_and_register_channels_for_agents() -{ - cout << "Creating and registering channels for agents" << endl; - char* c_name_of_current_channel = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_AGENT_NAME.c_str()); - Channel* c_aa_FC6504_Y = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); - strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_AGENT_NAME.c_str()); - Channel* c_aa_FC6504 = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); - strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_AGENT_NAME.c_str()); - Channel* c_aa_FC6504_SP = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); - strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_AGENT_NAME.c_str()); - Channel* c_aa_PI6584 = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); - - vec_of_Channels_for_Agents.push_back(c_aa_FC6504_Y); - vec_of_Channels_for_Agents.push_back(c_aa_FC6504); - vec_of_Channels_for_Agents.push_back(c_aa_FC6504_SP); - vec_of_Channels_for_Agents.push_back(c_aa_PI6584); - - cout << vec_of_Channels_for_Agents.size() << " channels for agents were created" << endl; - - delete c_name_of_current_channel; -} - -void mount_sensors_in_agents() -{ - Agent* current_agent; - Sensor* current_sensor; - Channel* current_sensor_channel; - unsigned int size_of_vec_sensor = 0; - unsigned int index = 0; - - size_of_vec_sensor = vec_of_Sensors.size(); - cout << "mounting sensors in agents." << endl; - //it is assumed that the corresponding sensors and agents and channels are always at the same - //position in the different vectors, if not then you have to add an search algorithm for it. - for(index = 0; index < size_of_vec_sensor; index++) - { - current_agent = vec_of_Agents[index]; - current_sensor = vec_of_Sensors[index]; - current_sensor_channel = vec_of_Channels_for_Sensors[index]; - mount_sensorInAgent(current_agent, current_sensor, current_sensor_channel); - } - cout << size_of_vec_sensor << " sensors in agents were mounted" << endl; -} - -void mount_agents_in_agents() -{ - Agent* current_agent; - Agent* viability_Monitor; - Channel* current_agent_channel; - unsigned int size_of_vec_agents = 0; - unsigned int index = 0; - - size_of_vec_agents = vec_of_Agents.size(); - //it is assumed that the viability agent is at the last position in the vector - viability_Monitor = vec_of_Agents[size_of_vec_agents-1]; - //all agents and channels are registered to the viabilityMonitor agent - //so you have to subtract the viabilityMonitor from the number of elements to register - //it is assumed that all the corresponding channels and agents are placed at the same index - for(index = 0; index < size_of_vec_agents -1; index++) - { - current_agent = vec_of_Agents[index]; - current_agent_channel = vec_of_Channels_for_Agents[index]; - //only register if the agent is not the viability_monitor, otherwise you would register the viability monitor to itself. - if(current_agent != viability_Monitor) { - mount_agentInAgent(viability_Monitor, current_agent, current_agent_channel); - } - } - cout << size_of_vec_agents -1 << "agents were registered to the viability monitor" << endl; -} - -/* - * registers the channels for the data agents to the viability monitor - */ -void register_data_agents_in_agent_state_Handler() - -{ - Agent* viability_Monitor; - Channel* current_agent_channel; - unsigned int size_of_vec_channel_agents = 0; - unsigned int index = 0; - - size_of_vec_channel_agents = vec_of_Channels_for_Agents.size(); - //get the agent for the viabilityMonitor, it is assumed that it is at the last position - viability_Monitor = vec_of_Agents[vec_of_Agents.size()-1]; - //register all the channels to the viability monitor - for(index = 0; index < size_of_vec_channel_agents; index++) { - current_agent_channel = vec_of_Channels_for_Agents[index]; - if(index != INDEX_OUTPUT) { - registerSlaveAgentAsInputVariableInStateHandler(viability_Monitor, current_agent_channel); - } - else{ - registerSlaveAgentAsOutputVariableInStateHandler(viability_Monitor, current_agent_channel); +#include + +#include "configCAMforNewMotor.h" + +#define CAM_FOR_FLUID 1 +#define CAM_FOR_NEWMOTOR 2 + +#define PRINT +#define STOP_AFTER_SUMMARY + + + +int main(int argc, char *argv[]) { + + // paths config + //TODO: maybe change char[] to String + char datasetPath[700]; + char destinationPath[700]; + + // dataset config + char datasetName[200]; + unsigned int datasetLength; + + // CAM System config + int camConfigOption; + + // CAM Values config (fuzzy functions etc.) + float innerBoundSimDif; + float outerBoundSimDif; + int boundTimeInSamples; + float innerBoundDrift; + float outerBoundDrift; + int boundBrokenTime; + int downSamplingFactor; + + + //if the only argument is the name of the executable itself. + if (argc <= 1) { + //configure here everything out of the C++ code. + + + + } + else if (argc > 12) { + // paths config + sprintf_s(destinationPath, "%s", argv[1]); + sprintf_s(datasetPath, "%s", argv[2]); + + // dataset config + sprintf_s(datasetName, "%s", argv[3]); + datasetLength = (unsigned int)atoi(argv[4]); + + // CAM System config + camConfigOption = atoi(argv[5]); + + // CAM Values config (fuzzy functions etc.) + innerBoundSimDif = atof(argv[6]); + outerBoundSimDif = atof(argv[7]); + boundTimeInSamples = atoi(argv[8]); + innerBoundDrift = atof(argv[9]); + outerBoundDrift = atof(argv[10]); + boundBrokenTime = atoi(argv[11]); + downSamplingFactor = atoi(argv[12]); + + + + + +#ifdef PRINT + printf("destinationPath: %s\n\n", destinationPath); + printf("datasetPath: %s\n", datasetPath); + printf("datasetName: %s\n", datasetName); + printf("datasetLength: %u\n", datasetLength); + + printf("innerBoundSimDif: %f\n", innerBoundSimDif); + printf("outerBoundSimDif: %f\n", outerBoundSimDif); + printf("boundTimeInSamples: %i\n", boundTimeInSamples); + printf("innerBoundDrift: %f\n", innerBoundDrift); + printf("outerBoundDrift: %f\n", outerBoundDrift); + printf("boundBrokenTime: %i\n", boundBrokenTime); + printf("downSamplingFactor: %i\n", downSamplingFactor); + + + +#ifdef STOP_AFTER_SUMMARY + getchar(); +#endif // STOP_AFTER_SUMMARY +#endif + + if (camConfigOption == CAM_FOR_FLUID) { + //start Fluid CAM config + /* + configAndStartFluidExperiment( + destinationPath, datasetPath, datasetName, + datasetLength, innerBoundSimDif, outerBoundSimDif, + boundTimeInSamples, innerBoundDrift, + outerBoundDrift, boundBrokenTime, + downSamplingFactor); + */ + } + else if (camConfigOption == CAM_FOR_NEWMOTOR) { + //start newMotor CAM config + configAndStartNewMotorExperiment( + destinationPath, datasetPath, datasetName, + datasetLength, innerBoundSimDif, outerBoundSimDif, + boundTimeInSamples, innerBoundDrift, + outerBoundDrift, boundBrokenTime, + downSamplingFactor); } } } - -/* - * creates and register all the different linear function blocks - */ -void create_linear_function_blocks() -{ - //don't change the sequence, because later it is assumed that the functions are - //registered int the vector in this sequence - //if you change it you have also to change the sequence in the function mount_function_blocks_to_viability_monitor - create_same_state_deviation_function_block(); - create_another_state_deviation_function_block(); - create_state_time_function_block(); - create_another_state_time_function_block(); - create_valid_state_deviation_function_block(); - create_invalid_state_deviation_function_block(); - create_valid_state_time_function_block(); - create_invalid_state_time_function_block(); - create_confidence_state_drift_function_block(); - create_confidence_broken_function_block(); -} - -/* - * creates and register the linear function block for same state deviation - */ -void create_same_state_deviation_function_block() -{ - char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_SAME_STATE_DEV.c_str()); - LinearFunctionBlock* confSim2StateDev = new LinearFunctionBlock(c_name_of_current_func_block); - LinearFunction* funcConfSim2StateDev1 = new LinearFunction(CONF_SIM2_STATE_DEV_1); - funcConfSim2StateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); - funcConfSim2StateDev1->setKandD((float)0, (float)0); - confSim2StateDev->addLinearFunction(funcConfSim2StateDev1); - LinearFunction* funcConfSim2StateDev2 = new LinearFunction(CONF_SIM2_STATE_DEV_2); - funcConfSim2StateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); - funcConfSim2StateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)0, (float)-INNER_BOUND_SIM_DIF, (float)1); - confSim2StateDev->addLinearFunction(funcConfSim2StateDev2); - LinearFunction* funcConfSim2StateDev3 = new LinearFunction(CONF_SIM2_STATE_DEV_3); - funcConfSim2StateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); - funcConfSim2StateDev3->setKandD((float)0, (float)1); - confSim2StateDev->addLinearFunction(funcConfSim2StateDev3); - LinearFunction* funcConfSim2StateDev4 = new LinearFunction(CONF_SIM2_STATE_DEV_4); - funcConfSim2StateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); - funcConfSim2StateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)1, (float)OUTTER_BOUND_SIM_DIF, (float)0); - confSim2StateDev->addLinearFunction(funcConfSim2StateDev4); - LinearFunction* funcConfSim2StateDev5 = new LinearFunction(CONF_SIM2_STATE_DEV_5); - funcConfSim2StateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); - funcConfSim2StateDev5->setKandD((float)0, (float)0); - confSim2StateDev->addLinearFunction(funcConfSim2StateDev5); - - vec_of_linear_Function_Blocks.push_back(confSim2StateDev); - - delete c_name_of_current_func_block; -} - -/* - * creates and register another state deviation function block - */ -void create_another_state_deviation_function_block() -{ - char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_ANOTHER_STATE_DEV.c_str()); - LinearFunctionBlock* confDif2StateDev = new LinearFunctionBlock(c_name_of_current_func_block); - LinearFunction* funcConfDif2StateDev1 = new LinearFunction(CONF_DIF2_STATE_DEV_1); - funcConfDif2StateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); - funcConfDif2StateDev1->setKandD((float)0, (float)1); - confDif2StateDev->addLinearFunction(funcConfDif2StateDev1); - LinearFunction* funcConfDif2StateDev2 = new LinearFunction(CONF_DIF2_STATE_DEV_2); - funcConfDif2StateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); - funcConfDif2StateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)1, (float)-INNER_BOUND_SIM_DIF, (float)0); - confDif2StateDev->addLinearFunction(funcConfDif2StateDev2); - LinearFunction* funcConfDif2StateDev3 = new LinearFunction(CONF_DIF2_STATE_DEV_3); - funcConfDif2StateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); - funcConfDif2StateDev3->setKandD((float)0, (float)0); - confDif2StateDev->addLinearFunction(funcConfDif2StateDev3); - LinearFunction* funcConfDif2StateDev4 = new LinearFunction(CONF_DIF2_STATE_DEV_4); - funcConfDif2StateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); - funcConfDif2StateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)0, (float)OUTTER_BOUND_SIM_DIF, (float)1); - confDif2StateDev->addLinearFunction(funcConfDif2StateDev4); - LinearFunction* funcConfDif2StateDev5 = new LinearFunction(CONF_DIF2_STATE_DEV_5); - funcConfDif2StateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); - funcConfDif2StateDev5->setKandD((float)0, (float)1); - confDif2StateDev->addLinearFunction(funcConfDif2StateDev5); - - vec_of_linear_Function_Blocks.push_back(confDif2StateDev); - - delete c_name_of_current_func_block; -} - -void create_state_time_function_block() -{ - char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_SAME_TIME.c_str()); - LinearFunctionBlock* confSim2StateTime = new LinearFunctionBlock(c_name_of_current_func_block); - LinearFunction* funcConfSim2StateTime1 = new LinearFunction(CONF_SIM2_STATE_TIME_1); - funcConfSim2StateTime1->setDomain(false, true, (float)0); - funcConfSim2StateTime1->setKandD((float)0, (float)0); - confSim2StateTime->addLinearFunction(funcConfSim2StateTime1); - LinearFunction* funcConfSim2StateTime2 = new LinearFunction(CONF_SIM2_STATE_TIME_2); - funcConfSim2StateTime2->setDomain(true, (float)0, true, (float)LENGTH); - funcConfSim2StateTime2->setKandD((float)0, (float)0, (float)LENGTH, (float)1); - confSim2StateTime->addLinearFunction(funcConfSim2StateTime2); - LinearFunction* funcConfSim2StateTime3 = new LinearFunction(CONF_SIM2_STATE_TIME_3); - funcConfSim2StateTime3->setDomain(true, (float)LENGTH, false); - funcConfSim2StateTime3->setKandD((float)0, (float)1); - confSim2StateTime->addLinearFunction(funcConfSim2StateTime3); - - vec_of_linear_Function_Blocks.push_back(confSim2StateTime); - - delete c_name_of_current_func_block; -} - -void create_another_state_time_function_block() -{ - char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_ANOTHER_STATE_TIME.c_str()); - LinearFunctionBlock* confDif2StateTime = new LinearFunctionBlock(c_name_of_current_func_block); - LinearFunction* funcConfDif2StateTime1 = new LinearFunction(CONF_DIF2_STATE_TIME_1); - funcConfDif2StateTime1->setDomain(false, true, (float)0); - funcConfDif2StateTime1->setKandD((float)0, (float)1); - confDif2StateTime->addLinearFunction(funcConfDif2StateTime1); - LinearFunction* funcConfDif2StateTime2 = new LinearFunction(CONF_DIF2_STATE_TIME_2); - funcConfDif2StateTime2->setDomain(true, (float)0, true, (float)LENGTH); - funcConfDif2StateTime2->setKandD((float)0, (float)1, (float)LENGTH, (float)0); - confDif2StateTime->addLinearFunction(funcConfDif2StateTime2); - LinearFunction* funcConfDif2StateTime3 = new LinearFunction(CONF_DIF2_STATE_TIME_3); - funcConfDif2StateTime3->setDomain(true, (float)LENGTH, false); - funcConfDif2StateTime3->setKandD((float)0, (float)0); - confDif2StateTime->addLinearFunction(funcConfDif2StateTime3); - - vec_of_linear_Function_Blocks.push_back(confDif2StateTime); - - delete c_name_of_current_func_block; -} - -void create_valid_state_deviation_function_block() -{ - char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_VAILD_STATE_DEV.c_str()); - LinearFunctionBlock* confValidStateDev = new LinearFunctionBlock(c_name_of_current_func_block); - LinearFunction* funcConfValidStateDev1 = new LinearFunction(CONF_VALID_STATE_DEV_1); - funcConfValidStateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); - funcConfValidStateDev1->setKandD((float)0, (float)0); - confValidStateDev->addLinearFunction(funcConfValidStateDev1); - LinearFunction* funcConfValidStateDev2 = new LinearFunction(CONF_VALID_STATE_DEV_2); - funcConfValidStateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); - funcConfValidStateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)0, (float)-INNER_BOUND_SIM_DIF, (float)1); - confValidStateDev->addLinearFunction(funcConfValidStateDev2); - LinearFunction* funcConfValidStateDev3 = new LinearFunction(CONF_VALID_STATE_DEV_3); - funcConfValidStateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); - funcConfValidStateDev3->setKandD((float)0, (float)1); - confValidStateDev->addLinearFunction(funcConfValidStateDev3); - LinearFunction* funcConfValidStateDev4 = new LinearFunction(CONF_VALID_STATE_DEV_4); - funcConfValidStateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); - funcConfValidStateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)1, (float)OUTTER_BOUND_SIM_DIF, (float)0); - confValidStateDev->addLinearFunction(funcConfValidStateDev4); - LinearFunction* funcConfValidStateDev5 = new LinearFunction(CONF_VALID_STATE_DEV_5); - funcConfValidStateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); - funcConfValidStateDev5->setKandD((float)0, (float)0); - confValidStateDev->addLinearFunction(funcConfValidStateDev5); - - vec_of_linear_Function_Blocks.push_back(confValidStateDev); - - delete c_name_of_current_func_block; -} - -void create_invalid_state_deviation_function_block() -{ - char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_INVALID_STATE_DEV.c_str()); - LinearFunctionBlock* confInvalidStateDev = new LinearFunctionBlock(c_name_of_current_func_block); - LinearFunction* funcConfInvalidStateDev1 = new LinearFunction(CONF_INVALID_STATE_DEV_1); - funcConfInvalidStateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); - funcConfInvalidStateDev1->setKandD((float)0, (float)1); - confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev1); - LinearFunction* funcConfInvalidStateDev2 = new LinearFunction(CONF_INVALID_STATE_DEV_2); - funcConfInvalidStateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); - funcConfInvalidStateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)1, (float)-INNER_BOUND_SIM_DIF, (float)0); - confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev2); - LinearFunction* funcConfInvalidStateDev3 = new LinearFunction(CONF_INVALID_STATE_DEV_3); - funcConfInvalidStateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); - funcConfInvalidStateDev3->setKandD((float)0, (float)0); - confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev3); - LinearFunction* funcConfInvalidStateDev4 = new LinearFunction(CONF_INVALID_STATE_DEV_4); - funcConfInvalidStateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); - funcConfInvalidStateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)0, (float)OUTTER_BOUND_SIM_DIF, (float)1); - confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev4); - LinearFunction* funcConfInvalidStateDev5 = new LinearFunction(CONF_INVALID_STATE_DEV_5); - funcConfInvalidStateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); - funcConfInvalidStateDev5->setKandD((float)0, (float)1); - confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev5); - - vec_of_linear_Function_Blocks.push_back(confInvalidStateDev); - - delete c_name_of_current_func_block; -} - -void create_valid_state_time_function_block() -{ - char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_VALID_STATE_TIME.c_str()); - LinearFunctionBlock* confValidStateTime = new LinearFunctionBlock(c_name_of_current_func_block); - LinearFunction* funcConfValidStateTime1 = new LinearFunction(VALID_STATE_TIME_1); - funcConfValidStateTime1->setDomain(false, true, (float)0); - funcConfValidStateTime1->setKandD((float)0, (float)0); - confValidStateTime->addLinearFunction(funcConfValidStateTime1); - LinearFunction* funcConfValidStateTime2 = new LinearFunction(VALID_STATE_TIME_2); - funcConfValidStateTime2->setDomain(true, (float)0, true, (float)LENGTH); //10 - funcConfValidStateTime2->setKandD((float)0, (float)0, (float)LENGTH, (float)1); - confValidStateTime->addLinearFunction(funcConfValidStateTime2); - LinearFunction* funcConfValidStateTime3 = new LinearFunction(VALID_STATE_TIME_3); - funcConfValidStateTime3->setDomain(true, (float)LENGTH, false); - funcConfValidStateTime3->setKandD((float)0, (float)1); - confValidStateTime->addLinearFunction(funcConfValidStateTime3); - - vec_of_linear_Function_Blocks.push_back(confValidStateTime); - - delete c_name_of_current_func_block; -} -void create_invalid_state_time_function_block() -{ - char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_INVALID_STATE_TIME.c_str()); - LinearFunctionBlock* confInvalidStateTime = new LinearFunctionBlock(c_name_of_current_func_block); - LinearFunction* funcConfInvalidStateTime1 = new LinearFunction(INVALID_STATE_TIME_1); - funcConfInvalidStateTime1->setDomain(false, true, (float)0); - funcConfInvalidStateTime1->setKandD((float)0, (float)1); - confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime1); - LinearFunction* funcConfInvalidStateTime2 = new LinearFunction(INVALID_STATE_TIME_2); - funcConfInvalidStateTime2->setDomain(true, (float)0, true, (float)LENGTH); - funcConfInvalidStateTime2->setKandD((float)0, (float)1, (float)LENGTH, (float)0); - confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime2); - LinearFunction* funcConfInvalidStateTime3 = new LinearFunction(INVALID_STATE_TIME_3); - funcConfInvalidStateTime3->setDomain(true, (float)LENGTH, false); - funcConfInvalidStateTime3->setKandD((float)0, (float)0); - confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime3); - - vec_of_linear_Function_Blocks.push_back(confInvalidStateTime); - - delete c_name_of_current_func_block; -} - -void create_confidence_state_drift_function_block() -{ - char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_CONFIDENCE_STATE_DRIFTS.c_str()); - LinearFunctionBlock* confStateDrifts = new LinearFunctionBlock(c_name_of_current_func_block); - LinearFunction* functionConfidenceDriftDeviation1 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_1); - functionConfidenceDriftDeviation1->setDomain(false, true, (float)-OUTTER_BOUND_DRIFT); - functionConfidenceDriftDeviation1->setKandD((float)0, (float)1); - confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation1); - LinearFunction* functionConfidenceDriftDeviation2 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_2); - functionConfidenceDriftDeviation2->setDomain(true, (float)-OUTTER_BOUND_DRIFT, true, (float)-INNER_BOUND_DRIFT); - functionConfidenceDriftDeviation2->setKandD((float)-INNER_BOUND_DRIFT, (float)1, (float)-INNER_BOUND_DRIFT, (float)0); - confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation2); - LinearFunction* functionConfidenceDriftDeviation3 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_3); - functionConfidenceDriftDeviation3->setDomain(true, (float)-INNER_BOUND_DRIFT, true, (float)INNER_BOUND_DRIFT); - functionConfidenceDriftDeviation3->setKandD((float)0, (float)0); - confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation3); - LinearFunction* functionConfidenceDriftDeviation4 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_4); - functionConfidenceDriftDeviation4->setDomain(true, (float)INNER_BOUND_DRIFT, true, (float)OUTTER_BOUND_DRIFT); - functionConfidenceDriftDeviation4->setKandD((float)INNER_BOUND_DRIFT, (float)0, (float)OUTTER_BOUND_DRIFT, (float)1); - confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation4); - LinearFunction* functionConfidenceDriftDeviation5 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_5); - functionConfidenceDriftDeviation5->setDomain(true, (float)OUTTER_BOUND_DRIFT, false); - functionConfidenceDriftDeviation5->setKandD((float)0, (float)1); - confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation5); - - vec_of_linear_Function_Blocks.push_back(confStateDrifts); - - delete c_name_of_current_func_block; -} - -void create_confidence_broken_function_block() -{ - char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_CONFIDENCE_BROKEN.c_str()); - LinearFunctionBlock* confBroken = new LinearFunctionBlock(c_name_of_current_func_block); - LinearFunction* functionConfidenceBroken1 = new LinearFunction(CONFIDENCE_BROKEN_1); - functionConfidenceBroken1->setDomain(false, true, (float)0); - functionConfidenceBroken1->setKandD((float)0, (float)0); - confBroken->addLinearFunction(functionConfidenceBroken1); - LinearFunction* functionConfidenceBroken2 = new LinearFunction(CONFIDENCE_BROKEN_2); - functionConfidenceBroken2->setDomain(true, (float)0, true, (float)BOUND_BROKEN); - functionConfidenceBroken2->setKandD((float)0, (float)0, (float)BOUND_BROKEN, (float)1); - confBroken->addLinearFunction(functionConfidenceBroken2); - LinearFunction* functionConfidenceBroken3 = new LinearFunction(CONFIDENCE_BROKEN_3); - functionConfidenceBroken3->setDomain(true, (float)BOUND_BROKEN, false); - functionConfidenceBroken3->setKandD((float)0, (float)1); - confBroken->addLinearFunction(functionConfidenceBroken3); - - vec_of_linear_Function_Blocks.push_back(confBroken); - - delete c_name_of_current_func_block; -} - -/* - * mount the different function blocks to the viability monitor agent - */ -void mount_function_blocks_to_viability_monitor() -{ - Agent* viability_Monitor; - LinearFunctionBlock* current_Linear_Function_Bock; - unsigned int size_of_vec_lin_func_block = vec_of_linear_Function_Blocks.size(); - unsigned int index = 0; - - //it is assumed that the viability monitor is at the last position of the vector of agents - viability_Monitor = vec_of_Agents[vec_of_Agents.size()-1]; - for(index = 0; index < size_of_vec_lin_func_block; index++) { - current_Linear_Function_Bock = vec_of_linear_Function_Blocks[index]; - //it is assumed that the function blocks are added into the vector in the following sequence - switch(index) { - case 0: - viability_Monitor->get_stateHandler()->FuncBlockConfSim2StateDev = current_Linear_Function_Bock; - break; - case 1: - viability_Monitor->get_stateHandler()->FuncBlockConfDif2StateDev = current_Linear_Function_Bock; - break; - case 2: - viability_Monitor->get_stateHandler()->FuncBlockConfSim2StateTime = current_Linear_Function_Bock; - break; - case 3: - viability_Monitor->get_stateHandler()->FuncBlockConfDif2StateTime = current_Linear_Function_Bock; - break; - case 4: - viability_Monitor->get_stateHandler()->FuncBlockConfValStateDev = current_Linear_Function_Bock; - break; - case 5: - viability_Monitor->get_stateHandler()->FuncBlockConfInvStateDev = current_Linear_Function_Bock; - break; - case 6: - viability_Monitor->get_stateHandler()->FuncBlockConfValStateTime = current_Linear_Function_Bock; - break; - case 7: - viability_Monitor->get_stateHandler()->FuncBlockConfInvStateTime = current_Linear_Function_Bock; - break; - case 8: - viability_Monitor->get_stateHandler()->DriftDeviation = current_Linear_Function_Bock; - break; - case 9: - viability_Monitor->get_stateHandler()->FuncBlockConfBrokenSamples = current_Linear_Function_Bock; - break; - } - } -} - - -void create_all_testbenches() { - char* c_name_of_current_testbench = new char[MAX_LENGTH_NAME]; - strcpy(c_name_of_current_testbench, TEST_BENCH.c_str()); - cout << "Creating test bench" << endl; - Testbench* tb = create_testbench(c_name_of_current_testbench); - create_and_register_all_Testbench_Configs(tb); - vec_of_test_benches.push_back(tb); - - delete c_name_of_current_testbench; -} - -void create_csvr_modules() -{ - //sets the row in which the data starts, maybe row one contains the headers - unsigned int row = 2; - char* c_name_of_current_csv_module = new char[MAX_LENGTH_NAME]; - string current_reader_path_and_file_name; - cout << "Creating CSV Reader Modules" << endl; - - current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; - strcpy(c_name_of_current_csv_module, FIRST_MEASURED_DATA_CSV_NAME.c_str()); - CSVreaderModule* csvr_FC6504_Y = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),3,row); - - current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; - strcpy(c_name_of_current_csv_module, SECOND_MEASURED_DATA_CSV_NAME.c_str()); - CSVreaderModule* csvr_FC6504 = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),4,row); - - current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; - strcpy(c_name_of_current_csv_module, THIRD_MEASURED_DATA_CSV_NAME.c_str()); - CSVreaderModule* csvr_FC6504_SP = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),5,row); - - current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; - strcpy(c_name_of_current_csv_module, FOURTH_MEASURED_DATA_CSV_NAME.c_str()); - CSVreaderModule* csvr_PI6584 = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),6,row); - - vec_of_csv_readers.push_back(csvr_FC6504_Y); - vec_of_csv_readers.push_back(csvr_FC6504); - vec_of_csv_readers.push_back(csvr_FC6504_SP); - vec_of_csv_readers.push_back(csvr_PI6584); - - delete c_name_of_current_csv_module; -} - -/* - * all agents would be registered to all testbenches - */ -void register_agents_in_testbenches() -{ - Testbench* current_tb; - unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); - unsigned int index_tb = 0; - Agent* current_ag; - unsigned int size_of_vec_agents = vec_of_Agents.size(); - unsigned int index_agents = 0; - - cout << "registering agents in testbenches" << endl; - for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { - current_tb = vec_of_test_benches[index_tb]; - for(index_agents = 0; index_agents < size_of_vec_agents; index_agents++) { - current_ag = vec_of_Agents[index_agents]; - register_agentInTestbench(current_tb, current_ag); - } - } - cout << size_of_vec_agents << " agents were registered in every of the " << size_of_vec_test_benches << " testbenches" << endl; -} - -/* - * registering the sensors and the corresponding csv-readers in the testbenches - * it is assumed that the csv readers and the sensors are at the same index position - * in the vectors. - */ -void register_sensors_in_testbenches() -{ - Testbench* current_tb; - unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); - unsigned int index_tb = 0; - Sensor* current_se; - unsigned int size_of_vec_sensors = vec_of_Sensors.size(); - unsigned int index_sensors = 0; - CSVreaderModule* current_csv_reader; - unsigned int size_of_vec_csv_reader = vec_of_csv_readers.size(); - - if(size_of_vec_csv_reader != size_of_vec_sensors) { - cout << "Error, in sequence of data processing"; - cout << "Number of csv-readers should be equal to number of sensors" << endl; - } - else { - cout << "Registering sensors and their csv-readers in testbenches " << endl; - for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { - current_tb = vec_of_test_benches[index_tb]; - for(index_sensors = 0; index_sensors < size_of_vec_sensors; index_sensors++) { - current_se = vec_of_Sensors[index_sensors]; - //it is assumed that the sensor and the corresponding csv-reader is stored - //at the same position in the two different vectors - current_csv_reader = vec_of_csv_readers[index_sensors]; - register_sensorInTestbench(current_tb, current_se, current_csv_reader); - } - } - cout << size_of_vec_sensors << " Sensors and their csv-readers were registered to "; - cout << "every of the " << size_of_vec_test_benches << " testbenches" << endl; - } -} - -void register_channels_in_testbenches() -{ - register_channels_of_sensors_in_testbenches(); - - register_channels_of_actors_in_testbenches(); -} - -void register_channels_of_sensors_in_testbenches() -{ - Testbench* current_tb; - unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); - unsigned int index_tb = 0; - Channel* current_se_ch; - unsigned int size_of_vec_se_channel = vec_of_Channels_for_Sensors.size(); - unsigned int index_se_ch = 0; - - cout << "Registering channels of sensors in testbench" << endl; - for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { - current_tb = vec_of_test_benches[index_tb]; - for(index_se_ch = 0; index_se_ch < size_of_vec_se_channel; index_se_ch++) { - current_se_ch = vec_of_Channels_for_Sensors[index_se_ch]; - register_channelInTestbench(current_tb, current_se_ch); - } - } - cout << size_of_vec_se_channel << " channels of sensors were registered in "; - cout << size_of_vec_test_benches << " testbenches." << endl; - -} - -void register_channels_of_actors_in_testbenches() -{ - Testbench* current_tb; - unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); - unsigned int index_tb = 0; - Channel* current_se_ch; - unsigned int size_of_vec_ag_channel = vec_of_Channels_for_Agents.size(); - unsigned int index_se_ch = 0; - - cout << "Registering channels of agents in testbench" << endl; - for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { - current_tb = vec_of_test_benches[index_tb]; - for(index_se_ch = 0; index_se_ch < size_of_vec_ag_channel; index_se_ch++) { - current_se_ch = vec_of_Channels_for_Agents[index_se_ch]; - register_channelInTestbench(current_tb, current_se_ch); - } - } - cout << size_of_vec_ag_channel << " channels of agents were registered in "; - cout << size_of_vec_test_benches << " testbenches." << endl; -} - -void run_simulation_of_all_testbenches() -{ - - string pressed_key; - Testbench* current_tb; - vector vec_tb_configs; - Testbench_Config* current_tb_config; - unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); - unsigned int index_tb = 0; - unsigned int size_of_vec_test_bench_config; - unsigned int index_tb_cfg = 0; - unsigned int sim_rounds = -1; - const int start_row = 1; - if (FILE_NAME_OF_ENTIRE_DATA == "2017_01_07__05_46_fc6504.csv") { - sim_rounds = 720; - } - - cout << "Press any key to start the simulation of all testbenches." << endl; - getline(cin, pressed_key); - - for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++){ - current_tb = vec_of_test_benches[index_tb]; - index_tb_cfg = 0; - vec_tb_configs = current_tb->get_all_registered_testbench_configs(); - size_of_vec_test_bench_config = vec_tb_configs.size(); - for(index_tb_cfg = 0; index_tb_cfg < size_of_vec_test_bench_config; index_tb_cfg++){ - current_tb_config = vec_tb_configs[index_tb_cfg]; - current_tb->set_current_tb_config_index(index_tb_cfg); - current_tb->set_CSV_Writer_parameter(); - current_tb->set_config_values_in_linear_functions(); - //have to open new file first! with the CSV-Writer, for every round > 0 - current_tb->simulate(sim_rounds); - if(index_tb_cfg < size_of_vec_test_bench_config - 1) { - current_tb->set_CSV_Reader_row(start_row); - current_tb->set_CSV_Reader_to_beginning(); - current_tb->reset_States(); - } - } - } - cout << "Simulation of " << size_of_vec_test_benches << " testbenches successfully finished" << endl; -} - -void close_file_pointers() -{ - CSVreaderModule* current_csv_reader; - unsigned int size_of_vec_csv_reader = vec_of_csv_readers.size(); - unsigned int index_csv_reader; - for(index_csv_reader = 0; index_csv_reader < size_of_vec_csv_reader; index_csv_reader++) { - current_csv_reader = vec_of_csv_readers[index_csv_reader]; - current_csv_reader->close_file(); - } -} - -void empty_static_vectors() -{ - - empty_vec_Agent(); - empty_vec_Channel_Agent(); - empty_vec_Channel_Sensor(); - empty_vec_Sensors(); - empty_vec_csv_raders(); - empty_vec_linear_func_Blocks(); - empty_vec_TestBench(); - - vec_of_Channels_for_Agents.clear(); - vec_of_Channels_for_Sensors.clear(); - vec_of_Sensors.clear(); - vec_of_csv_readers.clear(); - vec_of_linear_Function_Blocks.clear(); -} - -void empty_vec_Agent() -{ - Agent* cur_Agent; - unsigned int size_of_vec_Agent = vec_of_Agents.size(); - unsigned int index_Agent; - for(index_Agent = 0; index_Agent < size_of_vec_Agent; index_Agent++){ - cur_Agent = vec_of_Agents[index_Agent]; - delete cur_Agent; - } - vec_of_Agents.clear(); -} - -void empty_vec_Channel_Agent() -{ - Channel* cur_Channel; - unsigned int size_of_vec_Chan_Agent = vec_of_Channels_for_Agents.size(); - unsigned int index_Channel; - for(index_Channel = 0; index_Channel < size_of_vec_Chan_Agent; index_Channel++){ - cur_Channel = vec_of_Channels_for_Agents[index_Channel]; - //delete cur_Channel; - } - vec_of_Channels_for_Agents.clear(); -} - -void empty_vec_Channel_Sensor() -{ - Channel* cur_Channel; - unsigned int size_of_vec_Chan_Sensor = vec_of_Channels_for_Sensors.size(); - unsigned int index_Channel; - for(index_Channel = 0; index_Channel < size_of_vec_Chan_Sensor; index_Channel++){ - cur_Channel = vec_of_Channels_for_Sensors[index_Channel]; - delete cur_Channel; - } - vec_of_Channels_for_Sensors.clear(); -} - -void empty_vec_Sensors() -{ - Sensor* cur_Sensor; - unsigned int size_of_vec_Chan_Sensor = vec_of_Sensors.size(); - unsigned int index_Sensor; - for(index_Sensor = 0; index_Sensor < size_of_vec_Chan_Sensor; index_Sensor++){ - cur_Sensor = vec_of_Sensors[index_Sensor]; - delete cur_Sensor; - } - vec_of_Sensors.clear(); -} - -void empty_vec_csv_raders() -{ - CSVreaderModule* cur_csv_reader; - unsigned int size_of_vec_csv_reader = vec_of_csv_readers.size(); - unsigned int index_csv_reader; - for(index_csv_reader = 0; index_csv_reader < size_of_vec_csv_reader; index_csv_reader++){ - cur_csv_reader = vec_of_csv_readers[index_csv_reader]; - delete cur_csv_reader; - } - vec_of_csv_readers.clear(); -} - -void empty_vec_linear_func_Blocks() -{ - LinearFunctionBlock* cur_lin_fun_block; - unsigned int size_of_vec_lin_fun_block= vec_of_linear_Function_Blocks.size(); - unsigned int index_lin_fun_block; - for(index_lin_fun_block = 0; index_lin_fun_block < size_of_vec_lin_fun_block; index_lin_fun_block++){ - cur_lin_fun_block = vec_of_linear_Function_Blocks[index_lin_fun_block]; - delete cur_lin_fun_block; - } - vec_of_linear_Function_Blocks.clear(); -} - -void empty_vec_TestBench() -{ - Testbench* current_tb; - unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); - unsigned int index_tb = 0; - - for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++){ - current_tb = vec_of_test_benches[index_tb]; - current_tb->free_resources(); - delete current_tb; - } - vec_of_test_benches.clear(); -} - diff --git a/Version_Max_07_05_2018_CMake/src/main.cpp b/Version_Max_07_05_2018_CMake/src/main_backup.cpp old mode 100755 new mode 100644 similarity index 99% copy from Version_Max_07_05_2018_CMake/src/main.cpp copy to Version_Max_07_05_2018_CMake/src/main_backup.cpp index f3045be..75d87d9 --- a/Version_Max_07_05_2018_CMake/src/main.cpp +++ b/Version_Max_07_05_2018_CMake/src/main_backup.cpp @@ -1,1128 +1,1129 @@ /* * main.cpp * * Created on: 25.05.2018 * Author: edwin willegger, edwin.willegger@tuwien.ac.at * This file is used to generate output data from measurements * from OMV for SAVE project. * In this case the data of the 18.12.2017 is analyzed. * Based on the implementation of Maximilian Götzinger. */ #include "Agent.h" #include "Channel.h" #include "create_unit.h" #include "CSVreaderModule.h" #include "inAgentsRegistrations.h" #include "mount_nodes.h" #include "register_in_testbench.h" #include "Sensor.h" #include "setupNode.h" #include #include #include #include #include #include "Testbench.h" #include "file_util.h" #include "LinearFunction.h" #include "LinearFunctionBlock.h" #include "Testbench_Config.h" using namespace std; /********************************************************************************************************************** ************************************************begin of global definitions of variables and constants *************** **********************************************************************************************************************/ //every n-th SAMBLING value will be read in from the CSV-Data-Input-Files. #define SAMPLING 1 //global vectors for the different elements static vector vec_of_Agents; static vector vec_of_Sensors; static vector vec_of_Channels_for_Sensors; static vector vec_of_Channels_for_Agents; static vector vec_of_linear_Function_Blocks; static vector vec_of_test_benches; static vector vec_of_csv_readers; //names of the measured data const string FIRST_MEASURED_DATA_NAME = "FC6504_Y"; //Input const string SECOND_MEASURED_DATA_NAME = "FC6504"; //Output const string THIRD_MEASURED_DATA_NAME = "FC6504_SP"; //Input const string FOURTH_MEASURED_DATA_NAME = "PI6584"; //Input //viability monitor const string VIABILITY_MONITOR = "ViabilityMonitor"; //index number of output const int INDEX_OUTPUT = 1; //name for the channels of the sensors and agents const string APPENDIX_FOR_CHANNEL_SENSOR_NAME = "(SA)"; const string FIRST_MEASURED_CHANNEL_SENSOR_NAME = FIRST_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string SECOND_MEASURED_CHANNEL_SENSOR_NAME = SECOND_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string THIRD_MEASURED_CHANNEL_SENSOR_NAME = THIRD_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string FOURTH_MEASURED_CHANNEL_SENSOR_NAME = FOURTH_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_SENSOR_NAME; const string APPENDIX_FOR_CHANNEL_AGENT_NAME = "(AA-UP)"; const string FIRST_MEASURED_CHANNEL_AGENT_NAME = FIRST_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; const string SECOND_MEASURED_CHANNEL_AGENT_NAME = SECOND_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; const string THIRD_MEASURED_CHANNEL_AGENT_NAME = THIRD_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; const string FOURTH_MEASURED_CHANNEL_AGENT_NAME = FOURTH_MEASURED_DATA_NAME + APPENDIX_FOR_CHANNEL_AGENT_NAME; #define TRANSFER_RATE_CHANNEL_SENSOR 0 #define TRANSFER_RATE_CHANNEL_AGENT MAX_BUFFER_LENGTH ////////////////////////////////////////////// /* //out of the outer_bound the function is 0 or 1 and within 1 or 0 depending on function or complementery. inner_bound_xxx = /----------=1----|------=1---------\ = inner_bound_xxxx outer_bound_xxx = / | \ / | \ 0=__________/ | \ = outer_bound_xxxx ______ = 0 -------------------------------------------------------------------------- */ //parameters of boundary for similar function #define OUTTER_BOUND_SIM_DIF 0.20 //outer bound e. g. 0.14 = 14 percent; testested with 0.20, 0.14, 0.06, #define INNER_BOUND_SIM_DIF 0.01 //inner bound e. g. 0.01 = 1 percent //same way as above but shows drift. #define OUTTER_BOUND_DRIFT OUTTER_BOUND_SIM_DIF * 3 #define INNER_BOUND_DRIFT OUTTER_BOUND_SIM_DIF //timer sagt, dass nach dem DOWNSAMPLING der Ausgang bis zu //n Werte später sich ändern darf, nachdem Sich der Eingang geändert hat. #define BOUND_BROKEN 2 //length where fuzzy function raises from 0 to 1 or 1 to 0 for the complementery. //history of the data depends of it, and should change, if it changes. #define LENGTH 10 //definitions for the testbench const string TEST_BENCH = "testbench"; //defintions for the csv-reader-modules const string APPENDIX_CSV_MODULES = " CSV-Reader"; const string FIRST_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; const string SECOND_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; const string THIRD_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; const string FOURTH_MEASURED_DATA_CSV_NAME = FILE_NAME_OF_ENTIRE_DATA + APPENDIX_CSV_MODULES; //to switch between different file configurations change the //DEFINES in file_util.h /********************************************************************************************************************** ************************************************end of global definitions of variables and constants ***************** **********************************************************************************************************************/ /********************************************************************************************************************** ************************************************begin of function prototypes ***************************************** **********************************************************************************************************************/ void create_and_register_all_Testbench_Configs(Testbench* current_tb); void create_and_register_All_Agents(); void set_working_cycle_of_All_Agents(); void create_and_register_All_Sensors(); void set_working_cycle_of_All_Sensors(); void create_and_register_channels(); void create_and_register_channels_for_sensors(); void create_and_register_channels_for_agents(); void mount_sensors_in_agents(); void mount_agents_in_agents(); void register_data_agents_in_agent_state_Handler(); void create_linear_function_blocks(); void create_same_state_deviation_function_block(); void create_another_state_deviation_function_block(); void create_state_time_function_block(); void create_another_state_time_function_block(); void create_valid_state_deviation_function_block(); void create_invalid_state_deviation_function_block(); void create_valid_state_time_function_block(); void create_invalid_state_time_function_block(); void create_confidence_state_drift_function_block(); void create_confidence_broken_function_block(); void mount_function_blocks_to_viability_monitor(); void create_all_testbenches(); void create_csvr_modules(); void register_agents_in_testbenches(); void register_sensors_in_testbenches(); void register_channels_in_testbenches(); void register_channels_of_sensors_in_testbenches(); void register_channels_of_actors_in_testbenches(); void set_config_values_in_linear_functions(Testbench* current_tb); void set_parameters_LinearFunctionBlock(LinearFunctionBlock* cur_lin_func_block); void set_parameters_LinearFunction(vector vec_Lin_Func); void set_CSV_Writer_parameter(Testbench* current_tb); void run_simulation_of_all_testbenches(); void close_file_pointers(); void empty_static_vectors(); void empty_vec_Agent(); void empty_vec_Channel_Agent(); void empty_vec_Channel_Sensor(); void empty_vec_Sensors(); void empty_vec_csv_raders(); void empty_vec_linear_func_Blocks(); void empty_vec_TestBench(); /********************************************************************************************************************** ************************************************end of function prototypes ******************************************* **********************************************************************************************************************/ int main() { + cout << "This program processes test data from OMV Steam Cracker furnaces." << endl; create_and_register_All_Agents(); set_working_cycle_of_All_Agents(); create_and_register_All_Sensors(); set_working_cycle_of_All_Sensors(); create_and_register_channels(); mount_sensors_in_agents(); mount_agents_in_agents(); register_data_agents_in_agent_state_Handler(); create_linear_function_blocks(); mount_function_blocks_to_viability_monitor(); create_all_testbenches(); create_csvr_modules(); register_agents_in_testbenches(); register_sensors_in_testbenches(); register_channels_in_testbenches(); run_simulation_of_all_testbenches(); //close_file_pointers(); //TODO memory free of all objects. empty_static_vectors(); cout << "Program finished successfully" << endl; return 0; } void create_and_register_all_Testbench_Configs(Testbench* current_tb) { One_Config_t one; one.bound_broken = 2; one.inner_bound_sim_dif = 0.02; one.outter_bound_sim_dif = 0.08; one.inner_bound_drift = 3 * one.outter_bound_sim_dif; one.inner_bound_drift = one.outter_bound_sim_dif; one.length = 10; Testbench_Config* cfg = new Testbench_Config(one); cfg->print(); current_tb->register_testbench_config(cfg); } /* * creates all the agents used in the measurement * and stores them into the global vector */ void create_and_register_All_Agents() { cout << "Creating Agents" << endl; char* c_name_of_current_agent = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_agent, FIRST_MEASURED_DATA_NAME.c_str()); Agent* a_FC6504_Y = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, SECOND_MEASURED_DATA_NAME.c_str()); Agent* a_FC6504 = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, THIRD_MEASURED_DATA_NAME.c_str()); Agent* a_FC6504_SP = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, FOURTH_MEASURED_DATA_NAME.c_str()); Agent* a_PI6584 = create_agent(c_name_of_current_agent); strcpy(c_name_of_current_agent, VIABILITY_MONITOR.c_str()); Agent* a_viabilityMonitor = create_agent(c_name_of_current_agent); vec_of_Agents.push_back(a_FC6504_Y); vec_of_Agents.push_back(a_FC6504); vec_of_Agents.push_back(a_FC6504_SP); vec_of_Agents.push_back(a_PI6584); vec_of_Agents.push_back(a_viabilityMonitor); cout << vec_of_Agents.size() << " agents were created" << endl; delete c_name_of_current_agent; } /* * the working_cycle for all registered agents is set */ void set_working_cycle_of_All_Agents() { unsigned int working_Cyle = SAMPLING; unsigned int size_of_vec_of_Agents = 0; unsigned int index = 0; Agent* current_Agent; size_of_vec_of_Agents = vec_of_Agents.size(); for(index = 0; index < size_of_vec_of_Agents; index++) { current_Agent = vec_of_Agents[index]; setWorkingCycleOfAgent(current_Agent, working_Cyle); } } /* * all necessary sensors are created and registered */ void create_and_register_All_Sensors() { cout << "Creating Sensors" << endl; char* c_name_of_current_sensor = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_sensor, FIRST_MEASURED_DATA_NAME.c_str()); Sensor* s_FC6504_Y = create_sensor(c_name_of_current_sensor); strcpy(c_name_of_current_sensor, SECOND_MEASURED_DATA_NAME.c_str()); Sensor* s_FC6504 = create_sensor(c_name_of_current_sensor); strcpy(c_name_of_current_sensor, THIRD_MEASURED_DATA_NAME.c_str()); Sensor* s_FC6504_SP = create_sensor(c_name_of_current_sensor); strcpy(c_name_of_current_sensor, FOURTH_MEASURED_DATA_NAME.c_str()); Sensor* s_PI6584 = create_sensor(c_name_of_current_sensor); vec_of_Sensors.push_back(s_FC6504_Y); vec_of_Sensors.push_back(s_FC6504); vec_of_Sensors.push_back(s_FC6504_SP); vec_of_Sensors.push_back(s_PI6584); cout << vec_of_Sensors.size() << " sensors were created." << endl; delete c_name_of_current_sensor; } /* * working cycle of all registered sensors is set */ void set_working_cycle_of_All_Sensors() { unsigned int working_Cyle = SAMPLING; unsigned int size_of_vec_of_Sensors = 0; unsigned int index = 0; Sensor* current_Sensor; size_of_vec_of_Sensors = vec_of_Sensors.size(); for(index = 0; index < size_of_vec_of_Sensors; index++) { current_Sensor = vec_of_Sensors[index]; setWorkingCycleOfSensor(current_Sensor, working_Cyle); } } /* * creating and registering all channels */ void create_and_register_channels() { create_and_register_channels_for_sensors(); create_and_register_channels_for_agents(); } /* * creating and registering the channels for the sensors. */ void create_and_register_channels_for_sensors() { cout << "Creating and registering channels for sensors" << endl; char* c_name_of_current_channel = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_FC6504_Y = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_FC6504 = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_FC6504_SP = create_channel(c_name_of_current_channel, 0); strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_SENSOR_NAME.c_str()); Channel* c_sa_PI6584 = create_channel(c_name_of_current_channel, 0); vec_of_Channels_for_Sensors.push_back(c_sa_FC6504_Y); vec_of_Channels_for_Sensors.push_back(c_sa_FC6504); vec_of_Channels_for_Sensors.push_back(c_sa_FC6504_SP); vec_of_Channels_for_Sensors.push_back(c_sa_PI6584); cout << vec_of_Channels_for_Sensors.size() << " channels for sensors were created" << endl; delete c_name_of_current_channel; } /* * creating and registering the channels for the agents */ void create_and_register_channels_for_agents() { cout << "Creating and registering channels for agents" << endl; char* c_name_of_current_channel = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_channel, FIRST_MEASURED_CHANNEL_AGENT_NAME.c_str()); Channel* c_aa_FC6504_Y = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); strcpy(c_name_of_current_channel, SECOND_MEASURED_CHANNEL_AGENT_NAME.c_str()); Channel* c_aa_FC6504 = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); strcpy(c_name_of_current_channel, THIRD_MEASURED_CHANNEL_AGENT_NAME.c_str()); Channel* c_aa_FC6504_SP = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); strcpy(c_name_of_current_channel, FOURTH_MEASURED_CHANNEL_AGENT_NAME.c_str()); Channel* c_aa_PI6584 = create_channel(c_name_of_current_channel, MAX_BUFFER_LENGTH); vec_of_Channels_for_Agents.push_back(c_aa_FC6504_Y); vec_of_Channels_for_Agents.push_back(c_aa_FC6504); vec_of_Channels_for_Agents.push_back(c_aa_FC6504_SP); vec_of_Channels_for_Agents.push_back(c_aa_PI6584); cout << vec_of_Channels_for_Agents.size() << " channels for agents were created" << endl; delete c_name_of_current_channel; } void mount_sensors_in_agents() { Agent* current_agent; Sensor* current_sensor; Channel* current_sensor_channel; unsigned int size_of_vec_sensor = 0; unsigned int index = 0; size_of_vec_sensor = vec_of_Sensors.size(); cout << "mounting sensors in agents." << endl; //it is assumed that the corresponding sensors and agents and channels are always at the same //position in the different vectors, if not then you have to add an search algorithm for it. for(index = 0; index < size_of_vec_sensor; index++) { current_agent = vec_of_Agents[index]; current_sensor = vec_of_Sensors[index]; current_sensor_channel = vec_of_Channels_for_Sensors[index]; mount_sensorInAgent(current_agent, current_sensor, current_sensor_channel); } cout << size_of_vec_sensor << " sensors in agents were mounted" << endl; } void mount_agents_in_agents() { Agent* current_agent; Agent* viability_Monitor; Channel* current_agent_channel; unsigned int size_of_vec_agents = 0; unsigned int index = 0; size_of_vec_agents = vec_of_Agents.size(); //it is assumed that the viability agent is at the last position in the vector viability_Monitor = vec_of_Agents[size_of_vec_agents-1]; //all agents and channels are registered to the viabilityMonitor agent //so you have to subtract the viabilityMonitor from the number of elements to register //it is assumed that all the corresponding channels and agents are placed at the same index for(index = 0; index < size_of_vec_agents -1; index++) { current_agent = vec_of_Agents[index]; current_agent_channel = vec_of_Channels_for_Agents[index]; //only register if the agent is not the viability_monitor, otherwise you would register the viability monitor to itself. if(current_agent != viability_Monitor) { mount_agentInAgent(viability_Monitor, current_agent, current_agent_channel); } } cout << size_of_vec_agents -1 << "agents were registered to the viability monitor" << endl; } /* * registers the channels for the data agents to the viability monitor */ void register_data_agents_in_agent_state_Handler() { Agent* viability_Monitor; Channel* current_agent_channel; unsigned int size_of_vec_channel_agents = 0; unsigned int index = 0; size_of_vec_channel_agents = vec_of_Channels_for_Agents.size(); //get the agent for the viabilityMonitor, it is assumed that it is at the last position viability_Monitor = vec_of_Agents[vec_of_Agents.size()-1]; //register all the channels to the viability monitor for(index = 0; index < size_of_vec_channel_agents; index++) { current_agent_channel = vec_of_Channels_for_Agents[index]; if(index != INDEX_OUTPUT) { registerSlaveAgentAsInputVariableInStateHandler(viability_Monitor, current_agent_channel); } else{ registerSlaveAgentAsOutputVariableInStateHandler(viability_Monitor, current_agent_channel); } } } /* * creates and register all the different linear function blocks */ void create_linear_function_blocks() { //don't change the sequence, because later it is assumed that the functions are //registered int the vector in this sequence //if you change it you have also to change the sequence in the function mount_function_blocks_to_viability_monitor create_same_state_deviation_function_block(); create_another_state_deviation_function_block(); create_state_time_function_block(); create_another_state_time_function_block(); create_valid_state_deviation_function_block(); create_invalid_state_deviation_function_block(); create_valid_state_time_function_block(); create_invalid_state_time_function_block(); create_confidence_state_drift_function_block(); create_confidence_broken_function_block(); } /* * creates and register the linear function block for same state deviation */ void create_same_state_deviation_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_SAME_STATE_DEV.c_str()); LinearFunctionBlock* confSim2StateDev = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfSim2StateDev1 = new LinearFunction(CONF_SIM2_STATE_DEV_1); funcConfSim2StateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); funcConfSim2StateDev1->setKandD((float)0, (float)0); confSim2StateDev->addLinearFunction(funcConfSim2StateDev1); LinearFunction* funcConfSim2StateDev2 = new LinearFunction(CONF_SIM2_STATE_DEV_2); funcConfSim2StateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); funcConfSim2StateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)0, (float)-INNER_BOUND_SIM_DIF, (float)1); confSim2StateDev->addLinearFunction(funcConfSim2StateDev2); LinearFunction* funcConfSim2StateDev3 = new LinearFunction(CONF_SIM2_STATE_DEV_3); funcConfSim2StateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); funcConfSim2StateDev3->setKandD((float)0, (float)1); confSim2StateDev->addLinearFunction(funcConfSim2StateDev3); LinearFunction* funcConfSim2StateDev4 = new LinearFunction(CONF_SIM2_STATE_DEV_4); funcConfSim2StateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); funcConfSim2StateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)1, (float)OUTTER_BOUND_SIM_DIF, (float)0); confSim2StateDev->addLinearFunction(funcConfSim2StateDev4); LinearFunction* funcConfSim2StateDev5 = new LinearFunction(CONF_SIM2_STATE_DEV_5); funcConfSim2StateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); funcConfSim2StateDev5->setKandD((float)0, (float)0); confSim2StateDev->addLinearFunction(funcConfSim2StateDev5); vec_of_linear_Function_Blocks.push_back(confSim2StateDev); delete c_name_of_current_func_block; } /* * creates and register another state deviation function block */ void create_another_state_deviation_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_ANOTHER_STATE_DEV.c_str()); LinearFunctionBlock* confDif2StateDev = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfDif2StateDev1 = new LinearFunction(CONF_DIF2_STATE_DEV_1); funcConfDif2StateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); funcConfDif2StateDev1->setKandD((float)0, (float)1); confDif2StateDev->addLinearFunction(funcConfDif2StateDev1); LinearFunction* funcConfDif2StateDev2 = new LinearFunction(CONF_DIF2_STATE_DEV_2); funcConfDif2StateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); funcConfDif2StateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)1, (float)-INNER_BOUND_SIM_DIF, (float)0); confDif2StateDev->addLinearFunction(funcConfDif2StateDev2); LinearFunction* funcConfDif2StateDev3 = new LinearFunction(CONF_DIF2_STATE_DEV_3); funcConfDif2StateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); funcConfDif2StateDev3->setKandD((float)0, (float)0); confDif2StateDev->addLinearFunction(funcConfDif2StateDev3); LinearFunction* funcConfDif2StateDev4 = new LinearFunction(CONF_DIF2_STATE_DEV_4); funcConfDif2StateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); funcConfDif2StateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)0, (float)OUTTER_BOUND_SIM_DIF, (float)1); confDif2StateDev->addLinearFunction(funcConfDif2StateDev4); LinearFunction* funcConfDif2StateDev5 = new LinearFunction(CONF_DIF2_STATE_DEV_5); funcConfDif2StateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); funcConfDif2StateDev5->setKandD((float)0, (float)1); confDif2StateDev->addLinearFunction(funcConfDif2StateDev5); vec_of_linear_Function_Blocks.push_back(confDif2StateDev); delete c_name_of_current_func_block; } void create_state_time_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_SAME_TIME.c_str()); LinearFunctionBlock* confSim2StateTime = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfSim2StateTime1 = new LinearFunction(CONF_SIM2_STATE_TIME_1); funcConfSim2StateTime1->setDomain(false, true, (float)0); funcConfSim2StateTime1->setKandD((float)0, (float)0); confSim2StateTime->addLinearFunction(funcConfSim2StateTime1); LinearFunction* funcConfSim2StateTime2 = new LinearFunction(CONF_SIM2_STATE_TIME_2); funcConfSim2StateTime2->setDomain(true, (float)0, true, (float)LENGTH); funcConfSim2StateTime2->setKandD((float)0, (float)0, (float)LENGTH, (float)1); confSim2StateTime->addLinearFunction(funcConfSim2StateTime2); LinearFunction* funcConfSim2StateTime3 = new LinearFunction(CONF_SIM2_STATE_TIME_3); funcConfSim2StateTime3->setDomain(true, (float)LENGTH, false); funcConfSim2StateTime3->setKandD((float)0, (float)1); confSim2StateTime->addLinearFunction(funcConfSim2StateTime3); vec_of_linear_Function_Blocks.push_back(confSim2StateTime); delete c_name_of_current_func_block; } void create_another_state_time_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_ANOTHER_STATE_TIME.c_str()); LinearFunctionBlock* confDif2StateTime = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfDif2StateTime1 = new LinearFunction(CONF_DIF2_STATE_TIME_1); funcConfDif2StateTime1->setDomain(false, true, (float)0); funcConfDif2StateTime1->setKandD((float)0, (float)1); confDif2StateTime->addLinearFunction(funcConfDif2StateTime1); LinearFunction* funcConfDif2StateTime2 = new LinearFunction(CONF_DIF2_STATE_TIME_2); funcConfDif2StateTime2->setDomain(true, (float)0, true, (float)LENGTH); funcConfDif2StateTime2->setKandD((float)0, (float)1, (float)LENGTH, (float)0); confDif2StateTime->addLinearFunction(funcConfDif2StateTime2); LinearFunction* funcConfDif2StateTime3 = new LinearFunction(CONF_DIF2_STATE_TIME_3); funcConfDif2StateTime3->setDomain(true, (float)LENGTH, false); funcConfDif2StateTime3->setKandD((float)0, (float)0); confDif2StateTime->addLinearFunction(funcConfDif2StateTime3); vec_of_linear_Function_Blocks.push_back(confDif2StateTime); delete c_name_of_current_func_block; } void create_valid_state_deviation_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_VAILD_STATE_DEV.c_str()); LinearFunctionBlock* confValidStateDev = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfValidStateDev1 = new LinearFunction(CONF_VALID_STATE_DEV_1); funcConfValidStateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); funcConfValidStateDev1->setKandD((float)0, (float)0); confValidStateDev->addLinearFunction(funcConfValidStateDev1); LinearFunction* funcConfValidStateDev2 = new LinearFunction(CONF_VALID_STATE_DEV_2); funcConfValidStateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); funcConfValidStateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)0, (float)-INNER_BOUND_SIM_DIF, (float)1); confValidStateDev->addLinearFunction(funcConfValidStateDev2); LinearFunction* funcConfValidStateDev3 = new LinearFunction(CONF_VALID_STATE_DEV_3); funcConfValidStateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); funcConfValidStateDev3->setKandD((float)0, (float)1); confValidStateDev->addLinearFunction(funcConfValidStateDev3); LinearFunction* funcConfValidStateDev4 = new LinearFunction(CONF_VALID_STATE_DEV_4); funcConfValidStateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); funcConfValidStateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)1, (float)OUTTER_BOUND_SIM_DIF, (float)0); confValidStateDev->addLinearFunction(funcConfValidStateDev4); LinearFunction* funcConfValidStateDev5 = new LinearFunction(CONF_VALID_STATE_DEV_5); funcConfValidStateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); funcConfValidStateDev5->setKandD((float)0, (float)0); confValidStateDev->addLinearFunction(funcConfValidStateDev5); vec_of_linear_Function_Blocks.push_back(confValidStateDev); delete c_name_of_current_func_block; } void create_invalid_state_deviation_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_INVALID_STATE_DEV.c_str()); LinearFunctionBlock* confInvalidStateDev = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfInvalidStateDev1 = new LinearFunction(CONF_INVALID_STATE_DEV_1); funcConfInvalidStateDev1->setDomain(false, true, (float)-OUTTER_BOUND_SIM_DIF); funcConfInvalidStateDev1->setKandD((float)0, (float)1); confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev1); LinearFunction* funcConfInvalidStateDev2 = new LinearFunction(CONF_INVALID_STATE_DEV_2); funcConfInvalidStateDev2->setDomain(true, (float)-OUTTER_BOUND_SIM_DIF, true, (float)-INNER_BOUND_SIM_DIF); funcConfInvalidStateDev2->setKandD((float)-OUTTER_BOUND_SIM_DIF, (float)1, (float)-INNER_BOUND_SIM_DIF, (float)0); confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev2); LinearFunction* funcConfInvalidStateDev3 = new LinearFunction(CONF_INVALID_STATE_DEV_3); funcConfInvalidStateDev3->setDomain(true, (float)-INNER_BOUND_SIM_DIF, true, (float)INNER_BOUND_SIM_DIF); funcConfInvalidStateDev3->setKandD((float)0, (float)0); confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev3); LinearFunction* funcConfInvalidStateDev4 = new LinearFunction(CONF_INVALID_STATE_DEV_4); funcConfInvalidStateDev4->setDomain(true, (float)INNER_BOUND_SIM_DIF, true, (float)OUTTER_BOUND_SIM_DIF); funcConfInvalidStateDev4->setKandD((float)INNER_BOUND_SIM_DIF, (float)0, (float)OUTTER_BOUND_SIM_DIF, (float)1); confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev4); LinearFunction* funcConfInvalidStateDev5 = new LinearFunction(CONF_INVALID_STATE_DEV_5); funcConfInvalidStateDev5->setDomain(true, (float)OUTTER_BOUND_SIM_DIF, false); funcConfInvalidStateDev5->setKandD((float)0, (float)1); confInvalidStateDev->addLinearFunction(funcConfInvalidStateDev5); vec_of_linear_Function_Blocks.push_back(confInvalidStateDev); delete c_name_of_current_func_block; } void create_valid_state_time_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_VALID_STATE_TIME.c_str()); LinearFunctionBlock* confValidStateTime = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfValidStateTime1 = new LinearFunction(VALID_STATE_TIME_1); funcConfValidStateTime1->setDomain(false, true, (float)0); funcConfValidStateTime1->setKandD((float)0, (float)0); confValidStateTime->addLinearFunction(funcConfValidStateTime1); LinearFunction* funcConfValidStateTime2 = new LinearFunction(VALID_STATE_TIME_2); funcConfValidStateTime2->setDomain(true, (float)0, true, (float)LENGTH); //10 funcConfValidStateTime2->setKandD((float)0, (float)0, (float)LENGTH, (float)1); confValidStateTime->addLinearFunction(funcConfValidStateTime2); LinearFunction* funcConfValidStateTime3 = new LinearFunction(VALID_STATE_TIME_3); funcConfValidStateTime3->setDomain(true, (float)LENGTH, false); funcConfValidStateTime3->setKandD((float)0, (float)1); confValidStateTime->addLinearFunction(funcConfValidStateTime3); vec_of_linear_Function_Blocks.push_back(confValidStateTime); delete c_name_of_current_func_block; } void create_invalid_state_time_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_INVALID_STATE_TIME.c_str()); LinearFunctionBlock* confInvalidStateTime = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* funcConfInvalidStateTime1 = new LinearFunction(INVALID_STATE_TIME_1); funcConfInvalidStateTime1->setDomain(false, true, (float)0); funcConfInvalidStateTime1->setKandD((float)0, (float)1); confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime1); LinearFunction* funcConfInvalidStateTime2 = new LinearFunction(INVALID_STATE_TIME_2); funcConfInvalidStateTime2->setDomain(true, (float)0, true, (float)LENGTH); funcConfInvalidStateTime2->setKandD((float)0, (float)1, (float)LENGTH, (float)0); confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime2); LinearFunction* funcConfInvalidStateTime3 = new LinearFunction(INVALID_STATE_TIME_3); funcConfInvalidStateTime3->setDomain(true, (float)LENGTH, false); funcConfInvalidStateTime3->setKandD((float)0, (float)0); confInvalidStateTime->addLinearFunction(funcConfInvalidStateTime3); vec_of_linear_Function_Blocks.push_back(confInvalidStateTime); delete c_name_of_current_func_block; } void create_confidence_state_drift_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_CONFIDENCE_STATE_DRIFTS.c_str()); LinearFunctionBlock* confStateDrifts = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* functionConfidenceDriftDeviation1 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_1); functionConfidenceDriftDeviation1->setDomain(false, true, (float)-OUTTER_BOUND_DRIFT); functionConfidenceDriftDeviation1->setKandD((float)0, (float)1); confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation1); LinearFunction* functionConfidenceDriftDeviation2 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_2); functionConfidenceDriftDeviation2->setDomain(true, (float)-OUTTER_BOUND_DRIFT, true, (float)-INNER_BOUND_DRIFT); functionConfidenceDriftDeviation2->setKandD((float)-INNER_BOUND_DRIFT, (float)1, (float)-INNER_BOUND_DRIFT, (float)0); confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation2); LinearFunction* functionConfidenceDriftDeviation3 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_3); functionConfidenceDriftDeviation3->setDomain(true, (float)-INNER_BOUND_DRIFT, true, (float)INNER_BOUND_DRIFT); functionConfidenceDriftDeviation3->setKandD((float)0, (float)0); confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation3); LinearFunction* functionConfidenceDriftDeviation4 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_4); functionConfidenceDriftDeviation4->setDomain(true, (float)INNER_BOUND_DRIFT, true, (float)OUTTER_BOUND_DRIFT); functionConfidenceDriftDeviation4->setKandD((float)INNER_BOUND_DRIFT, (float)0, (float)OUTTER_BOUND_DRIFT, (float)1); confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation4); LinearFunction* functionConfidenceDriftDeviation5 = new LinearFunction(CONFIDENCE_DRIFT_DEVIATION_5); functionConfidenceDriftDeviation5->setDomain(true, (float)OUTTER_BOUND_DRIFT, false); functionConfidenceDriftDeviation5->setKandD((float)0, (float)1); confStateDrifts->addLinearFunction(functionConfidenceDriftDeviation5); vec_of_linear_Function_Blocks.push_back(confStateDrifts); delete c_name_of_current_func_block; } void create_confidence_broken_function_block() { char* c_name_of_current_func_block = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_func_block, FUNC_BLOCK_NAME_CONFIDENCE_BROKEN.c_str()); LinearFunctionBlock* confBroken = new LinearFunctionBlock(c_name_of_current_func_block); LinearFunction* functionConfidenceBroken1 = new LinearFunction(CONFIDENCE_BROKEN_1); functionConfidenceBroken1->setDomain(false, true, (float)0); functionConfidenceBroken1->setKandD((float)0, (float)0); confBroken->addLinearFunction(functionConfidenceBroken1); LinearFunction* functionConfidenceBroken2 = new LinearFunction(CONFIDENCE_BROKEN_2); functionConfidenceBroken2->setDomain(true, (float)0, true, (float)BOUND_BROKEN); functionConfidenceBroken2->setKandD((float)0, (float)0, (float)BOUND_BROKEN, (float)1); confBroken->addLinearFunction(functionConfidenceBroken2); LinearFunction* functionConfidenceBroken3 = new LinearFunction(CONFIDENCE_BROKEN_3); functionConfidenceBroken3->setDomain(true, (float)BOUND_BROKEN, false); functionConfidenceBroken3->setKandD((float)0, (float)1); confBroken->addLinearFunction(functionConfidenceBroken3); vec_of_linear_Function_Blocks.push_back(confBroken); delete c_name_of_current_func_block; } /* * mount the different function blocks to the viability monitor agent */ void mount_function_blocks_to_viability_monitor() { Agent* viability_Monitor; LinearFunctionBlock* current_Linear_Function_Bock; unsigned int size_of_vec_lin_func_block = vec_of_linear_Function_Blocks.size(); unsigned int index = 0; //it is assumed that the viability monitor is at the last position of the vector of agents viability_Monitor = vec_of_Agents[vec_of_Agents.size()-1]; for(index = 0; index < size_of_vec_lin_func_block; index++) { current_Linear_Function_Bock = vec_of_linear_Function_Blocks[index]; //it is assumed that the function blocks are added into the vector in the following sequence switch(index) { case 0: viability_Monitor->get_stateHandler()->FuncBlockConfSim2StateDev = current_Linear_Function_Bock; break; case 1: viability_Monitor->get_stateHandler()->FuncBlockConfDif2StateDev = current_Linear_Function_Bock; break; case 2: viability_Monitor->get_stateHandler()->FuncBlockConfSim2StateTime = current_Linear_Function_Bock; break; case 3: viability_Monitor->get_stateHandler()->FuncBlockConfDif2StateTime = current_Linear_Function_Bock; break; case 4: viability_Monitor->get_stateHandler()->FuncBlockConfValStateDev = current_Linear_Function_Bock; break; case 5: viability_Monitor->get_stateHandler()->FuncBlockConfInvStateDev = current_Linear_Function_Bock; break; case 6: viability_Monitor->get_stateHandler()->FuncBlockConfValStateTime = current_Linear_Function_Bock; break; case 7: viability_Monitor->get_stateHandler()->FuncBlockConfInvStateTime = current_Linear_Function_Bock; break; case 8: viability_Monitor->get_stateHandler()->DriftDeviation = current_Linear_Function_Bock; break; case 9: viability_Monitor->get_stateHandler()->FuncBlockConfBrokenSamples = current_Linear_Function_Bock; break; } } } void create_all_testbenches() { char* c_name_of_current_testbench = new char[MAX_LENGTH_NAME]; strcpy(c_name_of_current_testbench, TEST_BENCH.c_str()); cout << "Creating test bench" << endl; Testbench* tb = create_testbench(c_name_of_current_testbench); create_and_register_all_Testbench_Configs(tb); vec_of_test_benches.push_back(tb); delete c_name_of_current_testbench; } void create_csvr_modules() { //sets the row in which the data starts, maybe row one contains the headers unsigned int row = 2; char* c_name_of_current_csv_module = new char[MAX_LENGTH_NAME]; string current_reader_path_and_file_name; cout << "Creating CSV Reader Modules" << endl; current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, FIRST_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_FC6504_Y = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),3,row); current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, SECOND_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_FC6504 = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),4,row); current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, THIRD_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_FC6504_SP = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),5,row); current_reader_path_and_file_name = PATH_TO_CSV_DATA_FILES + PATH_TO_DATE_OF_MEASUREMENT + PATH_TO_AN_MEASURMENT + FILE_NAME_OF_ENTIRE_DATA; strcpy(c_name_of_current_csv_module, FOURTH_MEASURED_DATA_CSV_NAME.c_str()); CSVreaderModule* csvr_PI6584 = create_CSVreaderModule(c_name_of_current_csv_module,current_reader_path_and_file_name.c_str(),6,row); vec_of_csv_readers.push_back(csvr_FC6504_Y); vec_of_csv_readers.push_back(csvr_FC6504); vec_of_csv_readers.push_back(csvr_FC6504_SP); vec_of_csv_readers.push_back(csvr_PI6584); delete c_name_of_current_csv_module; } /* * all agents would be registered to all testbenches */ void register_agents_in_testbenches() { Testbench* current_tb; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; Agent* current_ag; unsigned int size_of_vec_agents = vec_of_Agents.size(); unsigned int index_agents = 0; cout << "registering agents in testbenches" << endl; for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { current_tb = vec_of_test_benches[index_tb]; for(index_agents = 0; index_agents < size_of_vec_agents; index_agents++) { current_ag = vec_of_Agents[index_agents]; register_agentInTestbench(current_tb, current_ag); } } cout << size_of_vec_agents << " agents were registered in every of the " << size_of_vec_test_benches << " testbenches" << endl; } /* * registering the sensors and the corresponding csv-readers in the testbenches * it is assumed that the csv readers and the sensors are at the same index position * in the vectors. */ void register_sensors_in_testbenches() { Testbench* current_tb; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; Sensor* current_se; unsigned int size_of_vec_sensors = vec_of_Sensors.size(); unsigned int index_sensors = 0; CSVreaderModule* current_csv_reader; unsigned int size_of_vec_csv_reader = vec_of_csv_readers.size(); if(size_of_vec_csv_reader != size_of_vec_sensors) { cout << "Error, in sequence of data processing"; cout << "Number of csv-readers should be equal to number of sensors" << endl; } else { cout << "Registering sensors and their csv-readers in testbenches " << endl; for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { current_tb = vec_of_test_benches[index_tb]; for(index_sensors = 0; index_sensors < size_of_vec_sensors; index_sensors++) { current_se = vec_of_Sensors[index_sensors]; //it is assumed that the sensor and the corresponding csv-reader is stored //at the same position in the two different vectors current_csv_reader = vec_of_csv_readers[index_sensors]; register_sensorInTestbench(current_tb, current_se, current_csv_reader); } } cout << size_of_vec_sensors << " Sensors and their csv-readers were registered to "; cout << "every of the " << size_of_vec_test_benches << " testbenches" << endl; } } void register_channels_in_testbenches() { register_channels_of_sensors_in_testbenches(); register_channels_of_actors_in_testbenches(); } void register_channels_of_sensors_in_testbenches() { Testbench* current_tb; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; Channel* current_se_ch; unsigned int size_of_vec_se_channel = vec_of_Channels_for_Sensors.size(); unsigned int index_se_ch = 0; cout << "Registering channels of sensors in testbench" << endl; for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { current_tb = vec_of_test_benches[index_tb]; for(index_se_ch = 0; index_se_ch < size_of_vec_se_channel; index_se_ch++) { current_se_ch = vec_of_Channels_for_Sensors[index_se_ch]; register_channelInTestbench(current_tb, current_se_ch); } } cout << size_of_vec_se_channel << " channels of sensors were registered in "; cout << size_of_vec_test_benches << " testbenches." << endl; } void register_channels_of_actors_in_testbenches() { Testbench* current_tb; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; Channel* current_se_ch; unsigned int size_of_vec_ag_channel = vec_of_Channels_for_Agents.size(); unsigned int index_se_ch = 0; cout << "Registering channels of agents in testbench" << endl; for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++) { current_tb = vec_of_test_benches[index_tb]; for(index_se_ch = 0; index_se_ch < size_of_vec_ag_channel; index_se_ch++) { current_se_ch = vec_of_Channels_for_Agents[index_se_ch]; register_channelInTestbench(current_tb, current_se_ch); } } cout << size_of_vec_ag_channel << " channels of agents were registered in "; cout << size_of_vec_test_benches << " testbenches." << endl; } void run_simulation_of_all_testbenches() { string pressed_key; Testbench* current_tb; vector vec_tb_configs; Testbench_Config* current_tb_config; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; unsigned int size_of_vec_test_bench_config; unsigned int index_tb_cfg = 0; unsigned int sim_rounds = -1; const int start_row = 1; if (FILE_NAME_OF_ENTIRE_DATA == "2017_01_07__05_46_fc6504.csv") { sim_rounds = 720; } cout << "Press any key to start the simulation of all testbenches." << endl; getline(cin, pressed_key); for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++){ current_tb = vec_of_test_benches[index_tb]; index_tb_cfg = 0; vec_tb_configs = current_tb->get_all_registered_testbench_configs(); size_of_vec_test_bench_config = vec_tb_configs.size(); for(index_tb_cfg = 0; index_tb_cfg < size_of_vec_test_bench_config; index_tb_cfg++){ current_tb_config = vec_tb_configs[index_tb_cfg]; current_tb->set_current_tb_config_index(index_tb_cfg); current_tb->set_CSV_Writer_parameter(); current_tb->set_config_values_in_linear_functions(); //have to open new file first! with the CSV-Writer, for every round > 0 current_tb->simulate(sim_rounds); if(index_tb_cfg < size_of_vec_test_bench_config - 1) { current_tb->set_CSV_Reader_row(start_row); current_tb->set_CSV_Reader_to_beginning(); current_tb->reset_States(); } } } cout << "Simulation of " << size_of_vec_test_benches << " testbenches successfully finished" << endl; } void close_file_pointers() { CSVreaderModule* current_csv_reader; unsigned int size_of_vec_csv_reader = vec_of_csv_readers.size(); unsigned int index_csv_reader; for(index_csv_reader = 0; index_csv_reader < size_of_vec_csv_reader; index_csv_reader++) { current_csv_reader = vec_of_csv_readers[index_csv_reader]; current_csv_reader->close_file(); } } void empty_static_vectors() { empty_vec_Agent(); empty_vec_Channel_Agent(); empty_vec_Channel_Sensor(); empty_vec_Sensors(); empty_vec_csv_raders(); empty_vec_linear_func_Blocks(); empty_vec_TestBench(); vec_of_Channels_for_Agents.clear(); vec_of_Channels_for_Sensors.clear(); vec_of_Sensors.clear(); vec_of_csv_readers.clear(); vec_of_linear_Function_Blocks.clear(); } void empty_vec_Agent() { Agent* cur_Agent; unsigned int size_of_vec_Agent = vec_of_Agents.size(); unsigned int index_Agent; for(index_Agent = 0; index_Agent < size_of_vec_Agent; index_Agent++){ cur_Agent = vec_of_Agents[index_Agent]; delete cur_Agent; } vec_of_Agents.clear(); } void empty_vec_Channel_Agent() { Channel* cur_Channel; unsigned int size_of_vec_Chan_Agent = vec_of_Channels_for_Agents.size(); unsigned int index_Channel; for(index_Channel = 0; index_Channel < size_of_vec_Chan_Agent; index_Channel++){ cur_Channel = vec_of_Channels_for_Agents[index_Channel]; //delete cur_Channel; } vec_of_Channels_for_Agents.clear(); } void empty_vec_Channel_Sensor() { Channel* cur_Channel; unsigned int size_of_vec_Chan_Sensor = vec_of_Channels_for_Sensors.size(); unsigned int index_Channel; for(index_Channel = 0; index_Channel < size_of_vec_Chan_Sensor; index_Channel++){ cur_Channel = vec_of_Channels_for_Sensors[index_Channel]; delete cur_Channel; } vec_of_Channels_for_Sensors.clear(); } void empty_vec_Sensors() { Sensor* cur_Sensor; unsigned int size_of_vec_Chan_Sensor = vec_of_Sensors.size(); unsigned int index_Sensor; for(index_Sensor = 0; index_Sensor < size_of_vec_Chan_Sensor; index_Sensor++){ cur_Sensor = vec_of_Sensors[index_Sensor]; delete cur_Sensor; } vec_of_Sensors.clear(); } void empty_vec_csv_raders() { CSVreaderModule* cur_csv_reader; unsigned int size_of_vec_csv_reader = vec_of_csv_readers.size(); unsigned int index_csv_reader; for(index_csv_reader = 0; index_csv_reader < size_of_vec_csv_reader; index_csv_reader++){ cur_csv_reader = vec_of_csv_readers[index_csv_reader]; delete cur_csv_reader; } vec_of_csv_readers.clear(); } void empty_vec_linear_func_Blocks() { LinearFunctionBlock* cur_lin_fun_block; unsigned int size_of_vec_lin_fun_block= vec_of_linear_Function_Blocks.size(); unsigned int index_lin_fun_block; for(index_lin_fun_block = 0; index_lin_fun_block < size_of_vec_lin_fun_block; index_lin_fun_block++){ cur_lin_fun_block = vec_of_linear_Function_Blocks[index_lin_fun_block]; delete cur_lin_fun_block; } vec_of_linear_Function_Blocks.clear(); } void empty_vec_TestBench() { Testbench* current_tb; unsigned int size_of_vec_test_benches = vec_of_test_benches.size(); unsigned int index_tb = 0; for(index_tb = 0; index_tb < size_of_vec_test_benches; index_tb++){ current_tb = vec_of_test_benches[index_tb]; current_tb->free_resources(); delete current_tb; } vec_of_test_benches.clear(); } diff --git a/Version_Max_07_05_2018_CMake/src/mount_nodes.cpp b/Version_Max_07_05_2018_CMake/src/mount_nodes.cpp index 81d1a17..79e3609 100755 --- a/Version_Max_07_05_2018_CMake/src/mount_nodes.cpp +++ b/Version_Max_07_05_2018_CMake/src/mount_nodes.cpp @@ -1,408 +1,408 @@ #include "attach_modules.h" #include "mount_nodes.h" #include "rlutil.h" #include #define PRINT using namespace rlutil; bool mount_sensorInAgent(Agent* agent, Sensor* sensor, Channel* channel) { if(agent != NULL && sensor != NULL && channel != NULL) { #ifdef PRINT printf(" > Sensor "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", sensor->get_name()); + printf("%s ", sensor->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) ", sensor->get_id()); #endif // PRINT if(agent->get_sensorHandlerOfAgent()->mount_sensorIntoSensorSlot(channel) && sensor->mount_agent(channel)) { #ifdef PRINT setColor(TXTCOLOR_LIGHTGREEN); printf("mounted "); setColor(TXTCOLOR_GREY); printf("in Agent "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", agent->get_name()); + printf("%s ", agent->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", agent->get_id()); #endif // PRINT return true; } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf("couldn't be mounted in %s (id: %03u)\n", agent->get_name(), agent->get_id()); + printf("couldn't be mounted in %s (id: %03u)\n", agent->get_name().c_str(), agent->get_id()); setColor(TXTCOLOR_GREY); #endif // PRINT } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf(" > Agent, Sensor, or Channel is not valid\n"); setColor(TXTCOLOR_GREY); #endif // PRINT } return false; } /* void mount_sensor_in_agent(Agent* agent, Sensor* sensor, Channel* sensor_to_slave, unsigned int position) { printf(" > "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", sensor->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u) ", sensor->get_id()); if(agent->mount_sensor(sensor_to_slave, position) && sensor->mount_agent(sensor_to_slave)) { rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("mounted "); rlutil::setColor(TXTCOLOR_GREY); printf("in "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", agent->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n - on position %u\n", agent->get_id(), position); } else { rlutil::setColor(TXTCOLOR_LIGHTRED); printf("couldn't be mounted in %s (id: %03u) on position %u\n", agent->get_name(), agent->get_id(), position); rlutil::setColor(TXTCOLOR_GREY); } } */ /* void mount_sensor_in_agent(Agent* agent, Sensor* sensor, Channel* sensor_to_slave, Abstraction* abstraction) { printf(" > "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", sensor->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u) ", sensor->get_id()); if(agent->mount_sensor(sensor_to_slave, abstraction) && sensor->mount_agent(sensor_to_slave)) { rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("mounted "); rlutil::setColor(TXTCOLOR_GREY); printf("in "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", agent->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n - ", agent->get_id()); rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("connected "); rlutil::setColor(TXTCOLOR_GREY); printf("with Abstraction Module "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", abstraction->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", abstraction->get_id()); } else { rlutil::setColor(TXTCOLOR_LIGHTRED); printf("couldn't be mounted in %s (id: %03u) connected with Abstraction Module %s (id: %03u)\n", agent->get_name(), agent->get_id(), abstraction->get_name(), abstraction->get_id()); rlutil::setColor(TXTCOLOR_GREY); } } */ /* void mount_sensor_in_agent(Agent* agent, Sensor* sensor, Channel* sensor_to_slave, Confidence_Validator* confidence_validator) { printf(" > "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", sensor->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u) ", sensor->get_id()); if(agent->mount_sensor(sensor_to_slave, confidence_validator) && sensor->mount_agent(sensor_to_slave)) { rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("mounted "); rlutil::setColor(TXTCOLOR_GREY); printf("in "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", agent->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n - ", agent->get_id()); rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("connected "); rlutil::setColor(TXTCOLOR_GREY); printf("with Range of Validity "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", confidence_validator->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", confidence_validator->get_id()); } else { rlutil::setColor(TXTCOLOR_LIGHTRED); printf("couldn't be mounted in %s (id: %03u) connected with Look up Table %s (id: %03u)\n", agent->get_name(), agent->get_id(), confidence_validator->get_name(), confidence_validator->get_id()); rlutil::setColor(TXTCOLOR_GREY); } } */ bool mount_sensorInAgent(Agent* agent, Sensor* sensor, Channel* channel, HistoryModule* historyModule) { if(agent != NULL && sensor != NULL && channel != NULL && historyModule != NULL) { if(mount_sensorInAgent(agent, sensor, channel)) { return attach_historyModuleToSensorSlotInAgent(agent, sensor, channel, historyModule); } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf("Agent, Sensor, Channel, or HistoryModule is not valid\n"); setColor(TXTCOLOR_GREY); #endif // PRINT } return false; } /* void mount_sensor_in_agent(Agent* agent, Sensor* sensor, Channel* sensor_to_slave, Confidence_Validator* confidence_validator, Abstraction* abstraction) { printf(" > "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", sensor->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u) ", sensor->get_id()); if(agent->mount_sensor(sensor_to_slave, confidence_validator, abstraction) && sensor->mount_agent(sensor_to_slave)) { rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("mounted "); rlutil::setColor(TXTCOLOR_GREY); printf("in "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", agent->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n - ", agent->get_id()); rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("connected "); rlutil::setColor(TXTCOLOR_GREY); printf("with Range of Validity "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", confidence_validator->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n - ", confidence_validator->get_id()); rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("connected "); rlutil::setColor(TXTCOLOR_GREY); printf("with Abstraction Module "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", abstraction->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", abstraction->get_id()); } else { rlutil::setColor(TXTCOLOR_LIGHTRED); printf("couldn't be mounted in %s (id: %03u) connected with Look up Table %s (id: %03u) and Abstraction Module %s (id: %03u)\n", agent->get_name(), agent->get_id(), confidence_validator->get_name(), confidence_validator->get_id(), abstraction->get_name(), abstraction->get_id()); rlutil::setColor(TXTCOLOR_GREY); } } */ bool mount_agentInAgent(Agent *masteragent, Agent* slaveagent, Channel* channel) { if(masteragent != NULL && slaveagent != NULL && channel != NULL) { if(masteragent->get_slaveAgentHandlerOfAgent()->mount_slaveAgentIntoSlaveAgentSlot(channel)) { if(slaveagent->get_masterAgentHandlerOfAgent()->mount_masterAgentIntoSlaveAgentSlot(channel)) { #ifdef PRINT printf(" > Agent "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", slaveagent->get_name()); + printf("%s ", slaveagent->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) ", slaveagent->get_id()); setColor(TXTCOLOR_LIGHTGREEN); printf("mounted "); setColor(TXTCOLOR_GREY); printf("in Agent "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", masteragent->get_name()); + printf("%s ", masteragent->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", masteragent->get_id()); #endif // PRINT return true; } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf(" > Could not mount Master Agent %s (id: %03u) in Slave Agent %s (id: %03u)\n", masteragent->get_name(), masteragent->get_id(), slaveagent->get_name(), slaveagent->get_id()); + printf(" > Could not mount Master Agent %s (id: %03u) in Slave Agent %s (id: %03u)\n", masteragent->get_name().c_str(), masteragent->get_id(), slaveagent->get_name().c_str(), slaveagent->get_id()); setColor(TXTCOLOR_GREY); #endif // PRINT masteragent->get_slaveAgentHandlerOfAgent()->demount_slaveAgentIntoSlaveAgentSlot(channel); } } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf(" > One of the Agents or Channel not valid\n"); setColor(TXTCOLOR_GREY); #endif // PRINT } return false; /* if(masteragent->mount_slaveagent(slave_to_master, master_to_slave) && slaveagent->mount_masteragent(master_to_slave, slave_to_master)) { setColor(TXTCOLOR_LIGHTGREEN); printf("mounted "); setColor(TXTCOLOR_GREY); printf("in Agent "); setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", masteragent->get_name()); setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", masteragent->get_id()); if(master_to_slave != NULL && slave_to_master != NULL) { printf(" > bidirectional communication "); } else { printf(" > unidirectional communication "); if(master_to_slave != NULL) { printf("(Master to Slave: "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", master_to_slave->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)) ", master_to_slave->get_id()); } if(slave_to_master != NULL) { printf("(Slave to Master: "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", slave_to_master->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)) ", slave_to_master->get_id()); } } setColor(TXTCOLOR_LIGHTGREEN); printf("set\n"); setColor(TXTCOLOR_GREY); } else { setColor(TXTCOLOR_LIGHTRED); printf("couldn't be mounted in Agent %s (id: %03u)\n", masteragent->get_name(), masteragent->get_id()); setColor(TXTCOLOR_GREY); } */ } /* void mount_slaveagent_in_agent(Agent *masteragent, Agent* slaveagent, Channel* master_to_slave, Channel* slave_to_master, unsigned int position) { printf(" > Slave - "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", slaveagent->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u) ", slaveagent->get_id()); if(masteragent->mount_slaveagent(slave_to_master, master_to_slave, position) && slaveagent->mount_masteragent(master_to_slave, slave_to_master)) { rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("mounted "); rlutil::setColor(TXTCOLOR_GREY); printf("in Master - "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", masteragent->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n - on position %u\n - ", masteragent->get_id(), position); if(master_to_slave != NULL && slave_to_master != NULL) printf("bidirectional communication\n"); else printf("unidirectional communication\n"); if(master_to_slave != NULL) { printf(" - Master to Slave: "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", master_to_slave->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", master_to_slave->get_id()); } if(slave_to_master != NULL) { printf(" - Slave to Master: "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", slave_to_master->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", slave_to_master->get_id()); } } else { rlutil::setColor(TXTCOLOR_LIGHTRED); printf("couldn't be mounted in Master - %s (id: %03u) on position %u\n", masteragent->get_name(), masteragent->get_id(), position); rlutil::setColor(TXTCOLOR_GREY); } } */ /* void mount_slaveagent_in_agent(Agent *masteragent, Agent* slaveagent, Channel* master_to_slave, Channel* slave_to_master, Cross_Confidence_Validator* ccv) { printf(" > Slave - "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", slaveagent->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u) ", slaveagent->get_id()); if(masteragent->mount_slaveagent(slave_to_master, master_to_slave, ccv) && slaveagent->mount_masteragent(master_to_slave, slave_to_master)) { rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("mounted "); rlutil::setColor(TXTCOLOR_GREY); printf("in Master - "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", masteragent->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n - ", masteragent->get_id()); rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("connected "); rlutil::setColor(TXTCOLOR_GREY); printf("with Cross Confidence Validator "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", ccv->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n - ", ccv->get_id()); if(master_to_slave != NULL && slave_to_master != NULL) printf("bidirectional communication\n"); else printf("unidirectional communication\n"); if(master_to_slave != NULL) { printf(" - Master to Slave: "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", master_to_slave->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", master_to_slave->get_id()); } if(slave_to_master != NULL) { printf(" - Slave to Master: "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", slave_to_master->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", slave_to_master->get_id()); } } else { rlutil::setColor(TXTCOLOR_LIGHTRED); printf("couldn't be mounted in Master - %s (id: %03u) with Cross Confidence Validator %s (id: %03u)\n", masteragent->get_name(), masteragent->get_id(), ccv->get_name(), ccv->get_id()); rlutil::setColor(TXTCOLOR_GREY); } } */ /* void mount_bunchmodule_in_agent(Agent *agent, Bunch_Module* bunch_module) { printf(" > "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", bunch_module->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u) ", bunch_module->get_id()); if(agent->mount_bunch_module(bunch_module)) { rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("mounted "); rlutil::setColor(TXTCOLOR_GREY); printf("in "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); printf("%s ", agent->get_name()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", agent->get_id()); } else { rlutil::setColor(TXTCOLOR_LIGHTRED); printf("couldn't be mounted in %s (id: %03u)\n", agent->get_name(), agent->get_id()); rlutil::setColor(TXTCOLOR_GREY); } } */ diff --git a/Version_Max_07_05_2018_CMake/src/printError.cpp b/Version_Max_07_05_2018_CMake/src/printError.cpp index e9bb053..e849f14 100755 --- a/Version_Max_07_05_2018_CMake/src/printError.cpp +++ b/Version_Max_07_05_2018_CMake/src/printError.cpp @@ -1,16 +1,16 @@ #include #include "printError.h" #define PC_MODE -void printError(char* errorMsg) { +void printError(std::string errorMsg) { #ifdef PC_MODE - printf("%s\n", errorMsg); + printf("%s\n", errorMsg.c_str()); #endif } -void printError(char* errorMsg, const char* additionalInfo) { +void printError(std::string errorMsg, const char *additionalInfo) { #ifdef PC_MODE - printf("%s: %s\n", errorMsg, additionalInfo); + printf("%s: %s\n", errorMsg.c_str(), additionalInfo); #endif } diff --git a/Version_Max_07_05_2018_CMake/src/printError.h b/Version_Max_07_05_2018_CMake/src/printError.h index fea2169..22ce522 100755 --- a/Version_Max_07_05_2018_CMake/src/printError.h +++ b/Version_Max_07_05_2018_CMake/src/printError.h @@ -1,7 +1,9 @@ #ifndef H_PRINT_HEADERFILE #define H_PRINT_HEADERFILE -void printError(char*); -void printError(char* errorMsg, const char* additionalInfo); +#include + +void printError(std::string errorMsg); +void printError(std::string errorMsg, const char *additionalInfo); #endif \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/register_in_testbench.cpp b/Version_Max_07_05_2018_CMake/src/register_in_testbench.cpp index 79ec1a4..49bc5d0 100755 --- a/Version_Max_07_05_2018_CMake/src/register_in_testbench.cpp +++ b/Version_Max_07_05_2018_CMake/src/register_in_testbench.cpp @@ -1,130 +1,130 @@ #include "register_in_testbench.h" #include "attach_modulesToTestbench.h" #include "rlutil.h" #include #define PRINT using namespace rlutil; bool register_agentInTestbench(Testbench *tb, Agent *agent) { if(tb != NULL && agent != NULL) { #ifdef PRINT printf(" > Agent "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", agent->get_name()); + printf("%s ", agent->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) ", agent->get_id()); #endif // PRINT if(tb->register_agent(agent)) { #ifdef PRINT setColor(TXTCOLOR_LIGHTGREEN); printf("registered "); setColor(TXTCOLOR_GREY); printf("in Testbench "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s\n", tb->get_name()); + printf("%s\n", tb->get_name().c_str()); setColor(TXTCOLOR_GREY); #endif // PRINT return true; } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf("couldn't be registered in %s", tb->get_name()); + printf("couldn't be registered in %s", tb->get_name().c_str()); #endif // PRINT } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf(" > Testbench or Agent is not valid\n"); #endif // PRINT } setColor(TXTCOLOR_GREY); return false; } bool register_sensorInTestbench(Testbench *tb, Sensor *sensor) { if(tb != NULL && sensor != NULL) { #ifdef PRINT printf(" > Sensor "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", sensor->get_name()); + printf("%s ", sensor->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) ", sensor->get_id()); #endif // PRINT if(tb->register_sensor(sensor)) { #ifdef PRINT setColor(TXTCOLOR_LIGHTGREEN); printf("registered "); setColor(TXTCOLOR_GREY); printf("in "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s\n", tb->get_name()); + printf("%s\n", tb->get_name().c_str()); setColor(TXTCOLOR_GREY); #endif // PRINT return true; } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf("couldn't be registered in %s\n", tb->get_name()); + printf("couldn't be registered in %s\n", tb->get_name().c_str()); #endif // PRINT } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf(" > Testbench or sensor is not valid\n"); #endif // PRINT } setColor(TXTCOLOR_GREY); return false; } bool register_sensorInTestbench(Testbench *tb, Sensor *sensor, CSVreaderModule *csvReaderModule) { if(tb != NULL && sensor != NULL && csvReaderModule != NULL) { if(register_sensorInTestbench(tb, sensor)) { return attach_csvReaderModuleToSensorSlotInAgent(tb, sensor, csvReaderModule); } } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); printf("Testbench or sensor is not valid\n"); #endif // PRINT } setColor(TXTCOLOR_GREY); return false; } bool register_channelInTestbench(Testbench *tb, Channel *channel) { #ifdef PRINT printf(" > Channel "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", channel->get_name()); + printf("%s ", channel->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) ", channel->get_id()); #endif // PRINT if(tb->register_channel(channel)){ #ifdef PRINT setColor(TXTCOLOR_LIGHTGREEN); printf("registered "); setColor(TXTCOLOR_GREY); printf("in Testbench "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s\n", tb->get_name()); + printf("%s\n", tb->get_name().c_str()); #endif // PRINT } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf("couldn't be registered in %s\n", tb->get_name()); + printf("couldn't be registered in %s\n", tb->get_name().c_str()); #endif // PRINT } setColor(TXTCOLOR_GREY); return false; } diff --git a/Version_Max_07_05_2018_CMake/src/rlutil.h b/Version_Max_07_05_2018_CMake/src/rlutil.h index 7f79138..2c5ea7a 100755 --- a/Version_Max_07_05_2018_CMake/src/rlutil.h +++ b/Version_Max_07_05_2018_CMake/src/rlutil.h @@ -1,779 +1,779 @@ #pragma once /** * File: rlutil.h * * About: Description * This file provides some useful utilities for console mode * roguelike game development with C and C++. It is aimed to * be cross-platform (at least Windows and Linux). * * About: Copyright * (C) 2010 Tapio Vierros * * About: Licensing * See */ //#ifndef RLUTIL_HEADERFILE //#define RLUTIL_HEADERFILE /// Define: RLUTIL_USE_ANSI /// Define this to use ANSI escape sequences also on Windows /// (defaults to using WinAPI instead). #if 0 #define RLUTIL_USE_ANSI #endif /// Define: RLUTIL_STRING_T /// Define/typedef this to your preference to override rlutil's string type. /// /// Defaults to std::string with C++ and char* with C. #if 0 #define RLUTIL_STRING_T char* #endif #ifndef RLUTIL_INLINE #ifdef _MSC_VER #define RLUTIL_INLINE __inline #else #define RLUTIL_INLINE static __inline__ #endif #endif #ifdef __cplusplus /// Common C++ headers #include #include #include // for getch() /// Namespace forward declarations namespace rlutil { RLUTIL_INLINE void locate(int x, int y); } //Work Arround (atartpoint) #define TXTCOLOR_BLACK 0 #define TXTCOLOR_BLUE 1 #define TXTCOLOR_GREEN 2 #define TXTCOLOR_CYAN 3 #define TXTCOLOR_RED 4 #define TXTCOLOR_MAGENTA 5 #define TXTCOLOR_BROWN 6 #define TXTCOLOR_GREY 7 #define TXTCOLOR_DARKGREY 8 #define TXTCOLOR_LIGHTBLUE 9 #define TXTCOLOR_LIGHTGREEN 10 #define TXTCOLOR_LIGHTCYAN 11 #define TXTCOLOR_LIGHTRED 12 #define TXTCOLOR_LIGHTMAGENTA 13 #define TXTCOLOR_YELLOW 14 #define TXTCOLOR_WHITE 15 #else #include // for getch() / printf() #include // for strlen() RLUTIL_INLINE void locate(int x, int y); // Forward declare for C to avoid warnings #endif // __cplusplus #ifdef _WIN32 #include // for WinAPI and Sleep() #define _NO_OLDNAMES // for MinGW compatibility #include // for getch() and kbhit() #define getch _getch #define kbhit _kbhit #else #include // for getch() and kbhit() #include // for getch(), kbhit() and (u)sleep() #include // for getkey() #include // for kbhit() #include // for kbhit() /// Function: getch /// Get character without waiting for Return to be pressed. /// Windows has this in conio.h RLUTIL_INLINE int getch(void) { // Here be magic. struct termios oldt, newt; int ch; tcgetattr(STDIN_FILENO, &oldt); newt = oldt; newt.c_lflag &= ~(ICANON | ECHO); tcsetattr(STDIN_FILENO, TCSANOW, &newt); ch = getchar(); tcsetattr(STDIN_FILENO, TCSANOW, &oldt); return ch; } /// Function: kbhit /// Determines if keyboard has been hit. /// Windows has this in conio.h RLUTIL_INLINE int kbhit(void) { // Here be dragons. static struct termios oldt, newt; int cnt = 0; tcgetattr(STDIN_FILENO, &oldt); newt = oldt; newt.c_lflag &= ~(ICANON | ECHO); newt.c_iflag = 0; // input mode newt.c_oflag = 0; // output mode newt.c_cc[VMIN] = 1; // minimum time to wait newt.c_cc[VTIME] = 1; // minimum characters to wait for tcsetattr(STDIN_FILENO, TCSANOW, &newt); ioctl(0, FIONREAD, &cnt); // Read count struct timeval tv; tv.tv_sec = 0; tv.tv_usec = 100; select(STDIN_FILENO+1, NULL, NULL, NULL, &tv); // A small time delay tcsetattr(STDIN_FILENO, TCSANOW, &oldt); return cnt; // Return number of characters } #endif // _WIN32 #ifndef gotoxy /// Function: gotoxy /// Same as . RLUTIL_INLINE void gotoxy(int x, int y) { #ifdef __cplusplus rlutil:: #endif locate(x,y); } #endif // gotoxy #ifdef __cplusplus /// Namespace: rlutil /// In C++ all functions except , and are arranged /// under namespace rlutil. That is because some platforms have them defined /// outside of rlutil. namespace rlutil { #endif /** * Defs: Internal typedefs and macros * RLUTIL_STRING_T - String type depending on which one of C or C++ is used * RLUTIL_PRINT(str) - Printing macro independent of C/C++ */ #ifdef __cplusplus #ifndef RLUTIL_STRING_T typedef std::string RLUTIL_STRING_T; #endif // RLUTIL_STRING_T #define RLUTIL_PRINT(st) do { std::cout << st; } while(false) #else // __cplusplus #ifndef RLUTIL_STRING_T typedef const char* RLUTIL_STRING_T; #endif // RLUTIL_STRING_T #define RLUTIL_PRINT(st) printf("%s", st) #endif // __cplusplus /** * Enums: Color codes * * BLACK - Black * BLUE - Blue * GREEN - Green * CYAN - Cyan * RED - Red * MAGENTA - Magenta / purple * BROWN - Brown / dark yellow * GREY - Grey / dark white * DARKGREY - Dark grey / light black * LIGHTBLUE - Light blue * LIGHTGREEN - Light green * LIGHTCYAN - Light cyan * LIGHTRED - Light red * LIGHTMAGENTA - Light magenta / light purple * YELLOW - Yellow (bright) * WHITE - White (bright) */ enum { BLACK, BLUE, GREEN, CYAN, RED, MAGENTA, BROWN, GREY, DARKGREY, LIGHTBLUE, LIGHTGREEN, LIGHTCYAN, LIGHTRED, LIGHTMAGENTA, YELLOW, WHITE }; /** * Consts: ANSI escape strings * * ANSI_CLS - Clears screen * ANSI_CONSOLE_TITLE_PRE - Prefix for changing the window title, print the window title in between * ANSI_CONSOLE_TITLE_POST - Suffix for changing the window title, print the window title in between * ANSI_ATTRIBUTE_RESET - Resets all attributes * ANSI_CURSOR_HIDE - Hides the cursor * ANSI_CURSOR_SHOW - Shows the cursor * ANSI_CURSOR_HOME - Moves the cursor home (0,0) * ANSI_BLACK - Black * ANSI_RED - Red * ANSI_GREEN - Green * ANSI_BROWN - Brown / dark yellow * ANSI_BLUE - Blue * ANSI_MAGENTA - Magenta / purple * ANSI_CYAN - Cyan * ANSI_GREY - Grey / dark white * ANSI_DARKGREY - Dark grey / light black * ANSI_LIGHTRED - Light red * ANSI_LIGHTGREEN - Light green * ANSI_YELLOW - Yellow (bright) * ANSI_LIGHTBLUE - Light blue * ANSI_LIGHTMAGENTA - Light magenta / light purple * ANSI_LIGHTCYAN - Light cyan * ANSI_WHITE - White (bright) * ANSI_BACKGROUND_BLACK - Black background * ANSI_BACKGROUND_RED - Red background * ANSI_BACKGROUND_GREEN - Green background * ANSI_BACKGROUND_YELLOW - Yellow background * ANSI_BACKGROUND_BLUE - Blue background * ANSI_BACKGROUND_MAGENTA - Magenta / purple background * ANSI_BACKGROUND_CYAN - Cyan background * ANSI_BACKGROUND_WHITE - White background */ const RLUTIL_STRING_T ANSI_CLS = "\033[2J\033[3J"; const RLUTIL_STRING_T ANSI_CONSOLE_TITLE_PRE = "\033]0;"; const RLUTIL_STRING_T ANSI_CONSOLE_TITLE_POST = "\007"; const RLUTIL_STRING_T ANSI_ATTRIBUTE_RESET = "\033[0m"; const RLUTIL_STRING_T ANSI_CURSOR_HIDE = "\033[?25l"; const RLUTIL_STRING_T ANSI_CURSOR_SHOW = "\033[?25h"; const RLUTIL_STRING_T ANSI_CURSOR_HOME = "\033[H"; const RLUTIL_STRING_T ANSI_BLACK = "\033[22;30m"; const RLUTIL_STRING_T ANSI_RED = "\033[22;31m"; const RLUTIL_STRING_T ANSI_GREEN = "\033[22;32m"; const RLUTIL_STRING_T ANSI_BROWN = "\033[22;33m"; const RLUTIL_STRING_T ANSI_BLUE = "\033[22;34m"; const RLUTIL_STRING_T ANSI_MAGENTA = "\033[22;35m"; const RLUTIL_STRING_T ANSI_CYAN = "\033[22;36m"; const RLUTIL_STRING_T ANSI_GREY = "\033[22;37m"; const RLUTIL_STRING_T ANSI_DARKGREY = "\033[01;30m"; const RLUTIL_STRING_T ANSI_LIGHTRED = "\033[01;31m"; const RLUTIL_STRING_T ANSI_LIGHTGREEN = "\033[01;32m"; const RLUTIL_STRING_T ANSI_YELLOW = "\033[01;33m"; const RLUTIL_STRING_T ANSI_LIGHTBLUE = "\033[01;34m"; const RLUTIL_STRING_T ANSI_LIGHTMAGENTA = "\033[01;35m"; const RLUTIL_STRING_T ANSI_LIGHTCYAN = "\033[01;36m"; const RLUTIL_STRING_T ANSI_WHITE = "\033[01;37m"; const RLUTIL_STRING_T ANSI_BACKGROUND_BLACK = "\033[40m"; const RLUTIL_STRING_T ANSI_BACKGROUND_RED = "\033[41m"; const RLUTIL_STRING_T ANSI_BACKGROUND_GREEN = "\033[42m"; const RLUTIL_STRING_T ANSI_BACKGROUND_YELLOW = "\033[43m"; const RLUTIL_STRING_T ANSI_BACKGROUND_BLUE = "\033[44m"; const RLUTIL_STRING_T ANSI_BACKGROUND_MAGENTA = "\033[45m"; const RLUTIL_STRING_T ANSI_BACKGROUND_CYAN = "\033[46m"; const RLUTIL_STRING_T ANSI_BACKGROUND_WHITE = "\033[47m"; // Remaining colors not supported as background colors /** * Enums: Key codes for keyhit() * * KEY_ESCAPE - Escape * KEY_ENTER - Enter * KEY_SPACE - Space * KEY_INSERT - Insert * KEY_HOME - Home * KEY_END - End * KEY_DELETE - Delete * KEY_PGUP - PageUp * KEY_PGDOWN - PageDown * KEY_UP - Up arrow * KEY_DOWN - Down arrow * KEY_LEFT - Left arrow * KEY_RIGHT - Right arrow * KEY_F1 - F1 * KEY_F2 - F2 * KEY_F3 - F3 * KEY_F4 - F4 * KEY_F5 - F5 * KEY_F6 - F6 * KEY_F7 - F7 * KEY_F8 - F8 * KEY_F9 - F9 * KEY_F10 - F10 * KEY_F11 - F11 * KEY_F12 - F12 * KEY_NUMDEL - Numpad del * KEY_NUMPAD0 - Numpad 0 * KEY_NUMPAD1 - Numpad 1 * KEY_NUMPAD2 - Numpad 2 * KEY_NUMPAD3 - Numpad 3 * KEY_NUMPAD4 - Numpad 4 * KEY_NUMPAD5 - Numpad 5 * KEY_NUMPAD6 - Numpad 6 * KEY_NUMPAD7 - Numpad 7 * KEY_NUMPAD8 - Numpad 8 * KEY_NUMPAD9 - Numpad 9 */ enum { KEY_ESCAPE = 0, KEY_ENTER = 1, KEY_SPACE = 32, KEY_INSERT = 2, KEY_HOME = 3, KEY_PGUP = 4, KEY_DELETE = 5, KEY_END = 6, KEY_PGDOWN = 7, KEY_UP = 14, KEY_DOWN = 15, KEY_LEFT = 16, KEY_RIGHT = 17, KEY_F1 = 18, KEY_F2 = 19, KEY_F3 = 20, KEY_F4 = 21, KEY_F5 = 22, KEY_F6 = 23, KEY_F7 = 24, KEY_F8 = 25, KEY_F9 = 26, KEY_F10 = 27, KEY_F11 = 28, KEY_F12 = 29, KEY_NUMDEL = 30, KEY_NUMPAD0 = 31, KEY_NUMPAD1 = 127, KEY_NUMPAD2 = 128, KEY_NUMPAD3 = 129, KEY_NUMPAD4 = 130, KEY_NUMPAD5 = 131, KEY_NUMPAD6 = 132, KEY_NUMPAD7 = 133, KEY_NUMPAD8 = 134, KEY_NUMPAD9 = 135 }; /// Function: getkey /// Reads a key press (blocking) and returns a key code. /// /// See /// /// Note: /// Only Arrows, Esc, Enter and Space are currently working properly. RLUTIL_INLINE int getkey(void) { #ifndef _WIN32 int cnt = kbhit(); // for ANSI escapes processing #endif int k = getch(); switch(k) { case 0: { int kk; switch (kk = getch()) { case 71: return KEY_NUMPAD7; case 72: return KEY_NUMPAD8; case 73: return KEY_NUMPAD9; case 75: return KEY_NUMPAD4; case 77: return KEY_NUMPAD6; case 79: return KEY_NUMPAD1; case 80: return KEY_NUMPAD2; case 81: return KEY_NUMPAD3; case 82: return KEY_NUMPAD0; case 83: return KEY_NUMDEL; default: return kk-59+KEY_F1; // Function keys }} case 224: { int kk; switch (kk = getch()) { case 71: return KEY_HOME; case 72: return KEY_UP; case 73: return KEY_PGUP; case 75: return KEY_LEFT; case 77: return KEY_RIGHT; case 79: return KEY_END; case 80: return KEY_DOWN; case 81: return KEY_PGDOWN; case 82: return KEY_INSERT; case 83: return KEY_DELETE; default: return kk-123+KEY_F1; // Function keys }} case 13: return KEY_ENTER; #ifdef _WIN32 case 27: return KEY_ESCAPE; #else // _WIN32 case 155: // single-character CSI case 27: { // Process ANSI escape sequences if (cnt >= 3 && getch() == '[') { switch (k = getch()) { case 'A': return KEY_UP; case 'B': return KEY_DOWN; case 'C': return KEY_RIGHT; case 'D': return KEY_LEFT; } } else return KEY_ESCAPE; } #endif // _WIN32 default: return k; } } /// Function: nb_getch /// Non-blocking getch(). Returns 0 if no key was pressed. RLUTIL_INLINE int nb_getch(void) { if (kbhit()) return getch(); else return 0; } /// Function: getANSIColor /// Return ANSI color escape sequence for specified number 0-15. /// /// See RLUTIL_INLINE RLUTIL_STRING_T getANSIColor(const int c) { switch (c) { case BLACK : return ANSI_BLACK; case BLUE : return ANSI_BLUE; // non-ANSI case GREEN : return ANSI_GREEN; case CYAN : return ANSI_CYAN; // non-ANSI case RED : return ANSI_RED; // non-ANSI case MAGENTA : return ANSI_MAGENTA; case BROWN : return ANSI_BROWN; case GREY : return ANSI_GREY; case DARKGREY : return ANSI_DARKGREY; case LIGHTBLUE : return ANSI_LIGHTBLUE; // non-ANSI case LIGHTGREEN : return ANSI_LIGHTGREEN; case LIGHTCYAN : return ANSI_LIGHTCYAN; // non-ANSI; case LIGHTRED : return ANSI_LIGHTRED; // non-ANSI; case LIGHTMAGENTA: return ANSI_LIGHTMAGENTA; case YELLOW : return ANSI_YELLOW; // non-ANSI case WHITE : return ANSI_WHITE; default: return ""; } } /// Function: getANSIBackgroundColor /// Return ANSI background color escape sequence for specified number 0-15. /// /// See RLUTIL_INLINE RLUTIL_STRING_T getANSIBackgroundColor(const int c) { switch (c) { case BLACK : return ANSI_BACKGROUND_BLACK; case BLUE : return ANSI_BACKGROUND_BLUE; case GREEN : return ANSI_BACKGROUND_GREEN; case CYAN : return ANSI_BACKGROUND_CYAN; case RED : return ANSI_BACKGROUND_RED; case MAGENTA: return ANSI_BACKGROUND_MAGENTA; case BROWN : return ANSI_BACKGROUND_YELLOW; case GREY : return ANSI_BACKGROUND_WHITE; default: return ""; } } /// Function: setColor /// Change color specified by number (Windows / QBasic colors). /// Don't change the background color /// /// See RLUTIL_INLINE void setColor(int c) { #if defined(_WIN32) && !defined(RLUTIL_USE_ANSI) HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(hConsole, &csbi); SetConsoleTextAttribute(hConsole, (csbi.wAttributes & 0xFFF0) | (WORD)c); // Foreground colors take up the least significant byte #else RLUTIL_PRINT(getANSIColor(c)); #endif } /// Function: setBackgroundColor /// Change background color specified by number (Windows / QBasic colors). /// Don't change the foreground color /// /// See RLUTIL_INLINE void setBackgroundColor(int c) { #if defined(_WIN32) && !defined(RLUTIL_USE_ANSI) HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(hConsole, &csbi); SetConsoleTextAttribute(hConsole, (csbi.wAttributes & 0xFF0F) | (((WORD)c) << 4)); // Background colors take up the second-least significant byte #else RLUTIL_PRINT(getANSIBackgroundColor(c)); #endif } /// Function: saveDefaultColor /// Call once to preserve colors for use in resetColor() /// on Windows without ANSI, no-op otherwise /// /// See /// See RLUTIL_INLINE int saveDefaultColor(void) { #if defined(_WIN32) && !defined(RLUTIL_USE_ANSI) static char initialized = 0; // bool static WORD attributes; if (!initialized) { CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi); attributes = csbi.wAttributes; initialized = 1; } return (int)attributes; #else return -1; #endif } /// Function: resetColor /// Reset color to default /// Requires a call to saveDefaultColor() to set the defaults /// /// See /// See /// See RLUTIL_INLINE void resetColor(void) { #if defined(_WIN32) && !defined(RLUTIL_USE_ANSI) SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), (WORD)saveDefaultColor()); #else RLUTIL_PRINT(ANSI_ATTRIBUTE_RESET); #endif } /// Function: cls /// Clears screen, resets all attributes and moves cursor home. RLUTIL_INLINE void cls(void) { #if defined(_WIN32) && !defined(RLUTIL_USE_ANSI) // Based on https://msdn.microsoft.com/en-us/library/windows/desktop/ms682022%28v=vs.85%29.aspx const HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); const COORD coordScreen = {0, 0}; DWORD cCharsWritten; CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(hConsole, &csbi); const DWORD dwConSize = csbi.dwSize.X * csbi.dwSize.Y; FillConsoleOutputCharacter(hConsole, (TCHAR)' ', dwConSize, coordScreen, &cCharsWritten); GetConsoleScreenBufferInfo(hConsole, &csbi); FillConsoleOutputAttribute(hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten); SetConsoleCursorPosition(hConsole, coordScreen); #else RLUTIL_PRINT(ANSI_CLS); RLUTIL_PRINT(ANSI_CURSOR_HOME); #endif } /// Function: locate /// Sets the cursor position to 1-based x,y. RLUTIL_INLINE void locate(int x, int y) { #if defined(_WIN32) && !defined(RLUTIL_USE_ANSI) COORD coord; // TODO: clamping/assert for x/y <= 0? coord.X = (SHORT)(x - 1); coord.Y = (SHORT)(y - 1); // Windows uses 0-based coordinates SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord); #else // _WIN32 || USE_ANSI #ifdef __cplusplus RLUTIL_PRINT("\033[" << y << ";" << x << "H"); #else // __cplusplus char buf[32]; sprintf(buf, "\033[%d;%df", y, x); RLUTIL_PRINT(buf); #endif // __cplusplus #endif // _WIN32 || USE_ANSI } /// Function: setString /// Prints the supplied string without advancing the cursor #ifdef __cplusplus RLUTIL_INLINE void setString(const RLUTIL_STRING_T & str_) { //Work Around (startpoint) - const char * const str_temp = str_.data(); //Changed: "str" -> "str_temp" + //const char * str_temp = str_.data(); //Changed: "str" -> "str_temp" wchar_t* str=new wchar_t[4096]; //Add this line //MultiByteToWideChar(CP_ACP, 0, str_temp, -1, str, 4096); //Add this line //Work Around (endpoint) unsigned int len = str_.size(); #else // __cplusplus RLUTIL_INLINE void setString(RLUTIL_STRING_T str) { unsigned int len = strlen(str); #endif // __cplusplus #if defined(_WIN32) && !defined(RLUTIL_USE_ANSI) HANDLE hConsoleOutput = GetStdHandle(STD_OUTPUT_HANDLE); DWORD numberOfCharsWritten; CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(hConsoleOutput, &csbi); WriteConsoleOutputCharacter(hConsoleOutput, str, len, csbi.dwCursorPosition, &numberOfCharsWritten); #else // _WIN32 || USE_ANSI RLUTIL_PRINT(str); #ifdef __cplusplus RLUTIL_PRINT("\033[" << len << 'D'); #else // __cplusplus char buf[3 + 20 + 1]; // 20 = max length of 64-bit unsigned int when printed as dec sprintf(buf, "\033[%uD", len); RLUTIL_PRINT(buf); #endif // __cplusplus #endif // _WIN32 || USE_ANSI } /// Function: setChar /// Sets the character at the cursor without advancing the cursor RLUTIL_INLINE void setChar(char ch) { const char buf[] = {ch, 0}; setString(buf); } /// Function: setCursorVisibility /// Shows/hides the cursor. RLUTIL_INLINE void setCursorVisibility(char visible) { #if defined(_WIN32) && !defined(RLUTIL_USE_ANSI) HANDLE hConsoleOutput = GetStdHandle( STD_OUTPUT_HANDLE ); CONSOLE_CURSOR_INFO structCursorInfo; GetConsoleCursorInfo( hConsoleOutput, &structCursorInfo ); // Get current cursor size structCursorInfo.bVisible = (visible ? TRUE : FALSE); SetConsoleCursorInfo( hConsoleOutput, &structCursorInfo ); #else // _WIN32 || USE_ANSI RLUTIL_PRINT((visible ? ANSI_CURSOR_SHOW : ANSI_CURSOR_HIDE)); #endif // _WIN32 || USE_ANSI } /// Function: hidecursor /// Hides the cursor. RLUTIL_INLINE void hidecursor(void) { setCursorVisibility(0); } /// Function: showcursor /// Shows the cursor. RLUTIL_INLINE void showcursor(void) { setCursorVisibility(1); } /// Function: msleep /// Waits given number of milliseconds before continuing. RLUTIL_INLINE void msleep(unsigned int ms) { #ifdef _WIN32 Sleep(ms); #else // usleep argument must be under 1 000 000 if (ms > 1000) sleep(ms/1000000); usleep((ms % 1000000) * 1000); #endif } /// Function: trows /// Get the number of rows in the terminal window or -1 on error. RLUTIL_INLINE int trows(void) { #ifdef _WIN32 CONSOLE_SCREEN_BUFFER_INFO csbi; if (!GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi)) return -1; else return csbi.srWindow.Bottom - csbi.srWindow.Top + 1; // Window height // return csbi.dwSize.Y; // Buffer height #else #ifdef TIOCGSIZE struct ttysize ts; ioctl(STDIN_FILENO, TIOCGSIZE, &ts); return ts.ts_lines; #elif defined(TIOCGWINSZ) struct winsize ts; ioctl(STDIN_FILENO, TIOCGWINSZ, &ts); return ts.ws_row; #else // TIOCGSIZE return -1; #endif // TIOCGSIZE #endif // _WIN32 } /// Function: tcols /// Get the number of columns in the terminal window or -1 on error. RLUTIL_INLINE int tcols(void) { #ifdef _WIN32 CONSOLE_SCREEN_BUFFER_INFO csbi; if (!GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi)) return -1; else return csbi.srWindow.Right - csbi.srWindow.Left + 1; // Window width // return csbi.dwSize.X; // Buffer width #else #ifdef TIOCGSIZE struct ttysize ts; ioctl(STDIN_FILENO, TIOCGSIZE, &ts); return ts.ts_cols; #elif defined(TIOCGWINSZ) struct winsize ts; ioctl(STDIN_FILENO, TIOCGWINSZ, &ts); return ts.ws_col; #else // TIOCGSIZE return -1; #endif // TIOCGSIZE #endif // _WIN32 } /// Function: anykey /// Waits until a key is pressed. /// In C++, it either takes no arguments /// or a template-type-argument-deduced /// argument. /// In C, it takes a const char* representing /// the message to be displayed, or NULL /// for no message. #ifdef __cplusplus RLUTIL_INLINE void anykey() { getch(); } template void anykey(const T& msg) { RLUTIL_PRINT(msg); #else RLUTIL_INLINE void anykey(RLUTIL_STRING_T msg) { if (msg) RLUTIL_PRINT(msg); #endif // __cplusplus getch(); } RLUTIL_INLINE void setConsoleTitle(RLUTIL_STRING_T title) { const char * true_title = #ifdef __cplusplus title.c_str(); #else // __cplusplus title; #endif // __cplusplus #if defined(_WIN32) && !defined(RLUTIL_USE_ANSI) SetConsoleTitleA(true_title); #else RLUTIL_PRINT(ANSI_CONSOLE_TITLE_PRE); RLUTIL_PRINT(true_title); RLUTIL_PRINT(ANSI_CONSOLE_TITLE_POST); #endif // defined(_WIN32) && !defined(RLUTIL_USE_ANSI) } // Classes are here at the end so that documentation is pretty. #ifdef __cplusplus /// Class: CursorHider /// RAII OOP wrapper for . /// Hides the cursor and shows it again /// when the object goes out of scope. struct CursorHider { CursorHider() { hidecursor(); } ~CursorHider() { showcursor(); } }; } // namespace rlutil #endif //#endif \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/setupNode.cpp b/Version_Max_07_05_2018_CMake/src/setupNode.cpp index 4d906f3..1705db2 100755 --- a/Version_Max_07_05_2018_CMake/src/setupNode.cpp +++ b/Version_Max_07_05_2018_CMake/src/setupNode.cpp @@ -1,54 +1,54 @@ #include "setupNode.h" #include "rlutil.h" #define PRINT using namespace rlutil; void setWorkingCycleOfSensor(Sensor* sensor, unsigned int workingCycle) { if (sensor->set_workingCycle(workingCycle)) { #ifdef PRINT printf(" > WorkingCycle of Sensor "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", sensor->get_name()); + printf("%s ", sensor->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) ", sensor->get_id()); setColor(TXTCOLOR_LIGHTGREEN); printf("set "); setColor(TXTCOLOR_GREY); printf("to %u\n", workingCycle); #endif // PRINT } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf(" > Couldn't set WorkingCycle of Sensor %s (id: %03u)\n", sensor->get_name(), sensor->get_id()); + printf(" > Couldn't set WorkingCycle of Sensor %s (id: %03u)\n", sensor->get_name().c_str(), sensor->get_id()); setColor(TXTCOLOR_GREY); #endif // PRINT } } void setWorkingCycleOfAgent(Agent* agent, unsigned int workingCycle) { if (agent->set_workingCycle(workingCycle)) { #ifdef PRINT printf(" > WorkingCycle of Agent "); setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", agent->get_name()); + printf("%s ", agent->get_name().c_str()); setColor(TXTCOLOR_GREY); printf("(id: %03u) ", agent->get_id()); setColor(TXTCOLOR_LIGHTGREEN); printf("set "); setColor(TXTCOLOR_GREY); printf("to %u\n", workingCycle); #endif // PRINT } else { #ifdef PRINT setColor(TXTCOLOR_LIGHTRED); - printf(" > Couldn't set WorkingCycle of Sensor %s (id: %03u)\n", agent->get_name(), agent->get_id()); + printf(" > Couldn't set WorkingCycle of Sensor %s (id: %03u)\n", agent->get_name().c_str(), agent->get_id()); setColor(TXTCOLOR_GREY); #endif // PRINT } } \ No newline at end of file diff --git a/Version_Max_07_05_2018_CMake/src/setup_lookuptable.cpp b/Version_Max_07_05_2018_CMake/src/setup_lookuptable.cpp index f1061b9..30300f4 100755 --- a/Version_Max_07_05_2018_CMake/src/setup_lookuptable.cpp +++ b/Version_Max_07_05_2018_CMake/src/setup_lookuptable.cpp @@ -1,52 +1,52 @@ #include "setup_lookuptable.h" #include #include "rlutil.h" void fill_lookuptable(Lookuptable* lut, int score, float lower_boundary, bool flag_lower_boundary_included, float upper_boundary, bool flag_upper_boundary_included) { printf(" > Score %i with Range ", score); if(flag_lower_boundary_included) printf("["); else printf("]"); printf("%6.2f,%6.2f ", lower_boundary, upper_boundary); if(flag_upper_boundary_included) printf("] "); else printf("[ "); if(lut->add_range_to_lookuptable(score, lower_boundary, flag_lower_boundary_included, upper_boundary, flag_upper_boundary_included)) { printf("was "); rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("added "); rlutil::setColor(TXTCOLOR_GREY); printf("to "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", lut->get_name()); + printf("%s ", lut->get_name().c_str()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u)\n", lut->get_id()); } else { rlutil::setColor(TXTCOLOR_LIGHTRED); - printf("couldn't be added to %s (id: %03u)\n", lut->get_name(), lut->get_id()); + printf("couldn't be added to %s (id: %03u)\n", lut->get_name().c_str(), lut->get_id()); rlutil::setColor(TXTCOLOR_GREY); } } void check_and_activate_lookuptable(Lookuptable* lut) { printf(" > "); rlutil::setColor(TXTCOLOR_LIGHTCYAN); - printf("%s ", lut->get_name()); + printf("%s ", lut->get_name().c_str()); rlutil::setColor(TXTCOLOR_GREY); printf("(id: %03u) ", lut->get_id()); if(lut->check_sort_and_activate()) { printf("seems to be "); rlutil::setColor(TXTCOLOR_LIGHTGREEN); printf("correct\n"); } else { rlutil::setColor(TXTCOLOR_LIGHTRED); - printf("is not correct\n", lut->get_name(), lut->get_id()); + printf("is not correct\n"); } rlutil::setColor(TXTCOLOR_GREY); } \ No newline at end of file