#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 <stdio.h>
#include "Testbench.h"
#include "file_util.h"

#include "LinearFunction.h"
#include "LinearFunctionBlock.h"


//#include "Lookuptable.h"
//#include "Clock.h"
//#include "setup_lookuptable.h"
//#include "setup_agent.h"
//#include "Cross_Confidence_Validator.h"
//#include "Continuous_Average.h"
//#include "rlutil.h"



//#define outterBoundSimDif 0.08	//0.12	//0.08	//0.04	//0.04
//#define innerBoundSimDif  0.03	//0.04	//0.01	//0.005	//0.001

#define outterBoundSimDif 0.14	//0.14 
#define innerBoundSimDif  0.01	//0.01

#define outterBoundDRIFT outterBoundSimDif*3	//0.12 
#define innerBoundDRIFT  outterBoundSimDif		//0.04

#define boundBroken 2 //2	//8

//NOTE: auch in StateHandler �ndern!!!!
#define length 10	//10

#define SAMPLING 50

//#define MODE_BROKEN
//#define MODE_HEALTHY
//#define MODE_DRIFT
#define MODE_NORMAL_UNCHANGED
//#define MODE_NORMAL_LOADCHANGE
//#define MODE_NORMAL_SPEEDCHANGE

#define CSV_FILTERED




int main(int argc, char* argv[])
{
	//unsigned int workingCycle = 300;	//sonst schafft er die unstetigkeit beim change load nicht (geht aber nur beim ungefilterten
										//auch bei speed change (geht bei filtered & unfiltered)
	unsigned int workingCycle = SAMPLING;
	//unsigned int workingCycle = 60;
	//unsigned int workingCycle = 1;

#if defined(MODE_BROKEN) || defined(MODE_HEALTHY)
	// --- Bearing Defect ---
	//create agents
	printf("Create Agents\n");
	Agent a_statorVoltage = create_agent("StatorVoltage");
	setWorkingCycleOfAgent(&a_statorVoltage, workingCycle);
	Agent a_statorCurrent_1 = create_agent("StatorCurrent1");
	setWorkingCycleOfAgent(&a_statorCurrent_1, workingCycle);
	Agent a_statorCurrent_2 = create_agent("StatorCurrent2");
	setWorkingCycleOfAgent(&a_statorCurrent_2, workingCycle);
	Agent a_statorCurrent_3 = create_agent("StatorCurrent3");
	setWorkingCycleOfAgent(&a_statorCurrent_3, workingCycle);
	Agent a_electromagneticTorque = create_agent("ElectromagneticTorque");
	setWorkingCycleOfAgent(&a_electromagneticTorque, workingCycle);
	Agent a_vibration_1 = create_agent("Vibration1");
	setWorkingCycleOfAgent(&a_vibration_1, workingCycle);
	Agent a_vibration_2 = create_agent("Vibration2");
	setWorkingCycleOfAgent(&a_vibration_2, workingCycle);
	Agent a_vibration_3 = create_agent("Vibration3");
	setWorkingCycleOfAgent(&a_vibration_3, workingCycle);
	Agent a_viabilityMonitor = create_agent("ViabilityMonitor");
	setWorkingCycleOfAgent(&a_viabilityMonitor, workingCycle);

	//create sensors
	printf("\nCreate Sensors\n");
	Sensor s_statorVoltage = create_sensor("Stator Voltage");
	setWorkingCycleOfSensor(&s_statorVoltage, workingCycle);
	Sensor s_statorCurrent_1 = create_sensor("Stator Current1");
	setWorkingCycleOfSensor(&s_statorCurrent_1, workingCycle);
	Sensor s_statorCurrent_2 = create_sensor("Stator Current2");
	setWorkingCycleOfSensor(&s_statorCurrent_2, workingCycle);
	Sensor s_statorCurrent_3 = create_sensor("Stator Current3");
	setWorkingCycleOfSensor(&s_statorCurrent_3, workingCycle);
	Sensor s_electromagneticTorque = create_sensor("Electromagnetic Torque");
	setWorkingCycleOfSensor(&s_electromagneticTorque, workingCycle);
	Sensor s_vibration_1 = create_sensor("Vibration1");
	setWorkingCycleOfSensor(&s_vibration_1, workingCycle);
	Sensor s_vibration_2 = create_sensor("Vibration2");
	setWorkingCycleOfSensor(&s_vibration_2, workingCycle);
	Sensor s_vibration_3 = create_sensor("Vibration3");
	setWorkingCycleOfSensor(&s_vibration_3, workingCycle);

	//create channels for sensors
	printf("\nCreate Channels for Sensors\n");
	Channel c_sa_statorVoltage = create_channel("Stator Voltage (SA)", 0);
	Channel c_sa_statorCurrent_1 = create_channel("Stator Current 1 (SA)", 0);
	Channel c_sa_statorCurrent_2 = create_channel("Stator Current 2 (SA)", 0);
	Channel c_sa_statorCurrent_3 = create_channel("Stator Current 3 (SA)", 0);
	Channel c_sa_electromagneticTorque = create_channel("Electromagnetic Torque (SA)", 0);
	Channel c_sa_vibration_1 = create_channel("Vibration 1 (SA)", 0);
	Channel c_sa_vibration_2 = create_channel("Vibration 2 (SA)", 0);
	Channel c_sa_vibration_3 = create_channel("Vibration 3 (SA)", 0);

	//create channels for sensors
	printf("\nCreate Channels for Agents\n");
	Channel c_aa_statorVoltage = create_channel("Stator Voltage (AA)", 0);
	Channel c_aa_statorCurrent_1 = create_channel("Stator Current 1 (AA)", 0);
	Channel c_aa_statorCurrent_2 = create_channel("Stator Current 2 (AA)", 0);
	Channel c_aa_statorCurrent_3 = create_channel("Stator Current 3 (AA)", 0);
	Channel c_aa_electromagneticTorque = create_channel("Electromagnetic Torque (AA)", 0);
	Channel c_aa_vibration_1 = create_channel("Vibration 1 (AA)", 0);
	Channel c_aa_vibration_2 = create_channel("Vibration 2 (AA)", 0);
	Channel c_aa_vibration_3 = create_channel("Vibration 3 (AA)", 0);

	//mount sensors in agents
	printf("\nMount Sensors in Agents\n");
	mount_sensorInAgent(&a_statorVoltage, &s_statorVoltage, &c_sa_statorVoltage);
	mount_sensorInAgent(&a_statorCurrent_1, &s_statorCurrent_1, &c_sa_statorCurrent_1);
	mount_sensorInAgent(&a_statorCurrent_2, &s_statorCurrent_2, &c_sa_statorCurrent_2);
	mount_sensorInAgent(&a_statorCurrent_3, &s_statorCurrent_3, &c_sa_statorCurrent_3);
	mount_sensorInAgent(&a_electromagneticTorque, &s_electromagneticTorque, &c_sa_electromagneticTorque);
	mount_sensorInAgent(&a_vibration_1, &s_vibration_1, &c_sa_vibration_1);
	mount_sensorInAgent(&a_vibration_2, &s_vibration_2, &c_sa_vibration_2);
	mount_sensorInAgent(&a_vibration_3, &s_vibration_3, &c_sa_vibration_3);

	//mount agents in agent(s)
	printf("\nMount Agents in Agents\n");
	mount_agentInAgent(&a_viabilityMonitor, &a_statorVoltage, &c_aa_statorVoltage);
	mount_agentInAgent(&a_viabilityMonitor, &a_statorCurrent_1, &c_aa_statorCurrent_1);
	mount_agentInAgent(&a_viabilityMonitor, &a_statorCurrent_2, &c_aa_statorCurrent_2);
	mount_agentInAgent(&a_viabilityMonitor, &a_statorCurrent_3, &c_aa_statorCurrent_3);
	mount_agentInAgent(&a_viabilityMonitor, &a_electromagneticTorque, &c_aa_electromagneticTorque);
	mount_agentInAgent(&a_viabilityMonitor, &a_vibration_1, &c_aa_vibration_1);
	mount_agentInAgent(&a_viabilityMonitor, &a_vibration_2, &c_aa_vibration_2);
	mount_agentInAgent(&a_viabilityMonitor, &a_vibration_3, &c_aa_vibration_3);

	//register agents in agents' stateHandler
	printf("\nRegister agents in agents' stateHandler\n");
	registerSlaveAgentAsInputVariableInStateHandler(&a_viabilityMonitor, &c_aa_statorVoltage);
	registerSlaveAgentAsOutputVariableInStateHandler(&a_viabilityMonitor, &c_aa_statorCurrent_1);
	registerSlaveAgentAsOutputVariableInStateHandler(&a_viabilityMonitor, &c_aa_statorCurrent_2);
	registerSlaveAgentAsOutputVariableInStateHandler(&a_viabilityMonitor, &c_aa_statorCurrent_3);
	registerSlaveAgentAsOutputVariableInStateHandler(&a_viabilityMonitor, &c_aa_electromagneticTorque);
	registerSlaveAgentAsOutputVariableInStateHandler(&a_viabilityMonitor, &c_aa_vibration_1);
	registerSlaveAgentAsOutputVariableInStateHandler(&a_viabilityMonitor, &c_aa_vibration_2);
	registerSlaveAgentAsOutputVariableInStateHandler(&a_viabilityMonitor, &c_aa_vibration_3);
#else
	// --- Other Modes ---
	//create agents
	printf("Create Agents\n");
	Agent a_statorVoltage		  = create_agent("StatorVoltage");
	setWorkingCycleOfAgent(&a_statorVoltage, workingCycle);
	Agent a_statorCurrent		  = create_agent("StatorCurrent");
	setWorkingCycleOfAgent(&a_statorCurrent, workingCycle);
	Agent a_speed				  = create_agent("Speed");
	setWorkingCycleOfAgent(&a_speed, workingCycle);
	Agent a_electromagneticTorque = create_agent("ElectromagneticTorque");
	setWorkingCycleOfAgent(&a_electromagneticTorque, workingCycle);
	Agent a_mechanicalTorque	  = create_agent("MechanicalTorque");
	setWorkingCycleOfAgent(&a_mechanicalTorque, workingCycle);
	Agent a_viabilityMonitor	  = create_agent("ViabilityMonitor");
	setWorkingCycleOfAgent(&a_viabilityMonitor, workingCycle);

	//create sensors
	printf("\nCreate Sensors\n");
	Sensor s_statorVoltage		   = create_sensor("Stator Voltage");
	setWorkingCycleOfSensor(&s_statorVoltage, workingCycle);
	Sensor s_statorCurrent		   = create_sensor("Stator Current");
	setWorkingCycleOfSensor(&s_statorCurrent, workingCycle);
	Sensor s_speed				   = create_sensor("Speed");
	setWorkingCycleOfSensor(&s_speed, workingCycle);
	Sensor s_electromagneticTorque = create_sensor("Electromagnetic Torque");
	setWorkingCycleOfSensor(&s_electromagneticTorque, workingCycle);
	Sensor s_mechanicalTorque	   = create_sensor("Mechanical Torque");
	setWorkingCycleOfSensor(&s_mechanicalTorque, workingCycle);

	//create channels for sensors
	printf("\nCreate Channels for Sensors\n");
	Channel c_sa_statorVoltage		  	= create_channel("Stator Voltage (SA)", 0);
	Channel c_sa_statorCurrent		  	= create_channel("Stator Current (SA)", 0);
	Channel c_sa_speed				  	= create_channel("Speed Sensor (SA)", 0);
	Channel c_sa_electromagneticTorque 	= create_channel("Electromagnetic Torque (SA)", 0);
	Channel c_sa_mechanicalTorque      	= create_channel("Mechanical Torque (SA)", 0);

	//create channels for sensors
	printf("\nCreate Channels for Agents\n");
	Channel c_aa_statorVoltage		   = create_channel("Stator Voltage (AA-UP)", MAX_BUFFER_LENGTH);
	Channel c_aa_statorCurrent		   = create_channel("Stator Current (AA-UP)", MAX_BUFFER_LENGTH);
	Channel c_aa_speed				   = create_channel("Speed Sensor (AA-UP)", MAX_BUFFER_LENGTH);
	Channel c_aa_electromagneticTorque = create_channel("Electromagnetic Torque (AA-UP)", MAX_BUFFER_LENGTH);
	Channel c_aa_mechanicalTorque      = create_channel("Mechanical Torque (AA-UP)", MAX_BUFFER_LENGTH);

	//mount sensors in agents
	printf("\nMount Sensors in Agents\n");
	mount_sensorInAgent(&a_statorVoltage,		  &s_statorVoltage,			&c_sa_statorVoltage);
	mount_sensorInAgent(&a_statorCurrent,		  &s_statorCurrent,			&c_sa_statorCurrent);
	mount_sensorInAgent(&a_speed,				  &s_speed,					&c_sa_speed);
	mount_sensorInAgent(&a_electromagneticTorque, &s_electromagneticTorque, &c_sa_electromagneticTorque);
	mount_sensorInAgent(&a_mechanicalTorque,	  &s_mechanicalTorque,		&c_sa_mechanicalTorque);

	//mount agents in agent(s)
	printf("\nMount Agents in Agents\n");
	mount_agentInAgent(&a_viabilityMonitor, &a_statorVoltage,		  &c_aa_statorVoltage);
	mount_agentInAgent(&a_viabilityMonitor, &a_statorCurrent,		  &c_aa_statorCurrent);
	mount_agentInAgent(&a_viabilityMonitor, &a_speed,				  &c_aa_speed);
	mount_agentInAgent(&a_viabilityMonitor, &a_electromagneticTorque, &c_aa_electromagneticTorque);
	mount_agentInAgent(&a_viabilityMonitor, &a_mechanicalTorque,	  &c_aa_mechanicalTorque);

	//register agents in agents' stateHandler
	printf("\nRegister agents in agents' stateHandler\n");
	registerSlaveAgentAsInputVariableInStateHandler(&a_viabilityMonitor, &c_aa_statorVoltage);
	registerSlaveAgentAsOutputVariableInStateHandler(&a_viabilityMonitor, &c_aa_statorCurrent);
	registerSlaveAgentAsOutputVariableInStateHandler(&a_viabilityMonitor, &c_aa_speed);
	registerSlaveAgentAsOutputVariableInStateHandler(&a_viabilityMonitor, &c_aa_electromagneticTorque);
	registerSlaveAgentAsInputVariableInStateHandler(&a_viabilityMonitor, &c_aa_mechanicalTorque);
#endif // defined(MODE_BROKEN) || defined(MODE_HEALTHY)
	




	/************************ FunctionBlocks Sim/Dif to State (NEU) ************************/
	
	//SAME STATE DEVIATION
	LinearFunctionBlock confSim2StateDev("funcBlock:confSim2StateDev");
	LinearFunction funcConfSim2StateDev1;
	funcConfSim2StateDev1.setDomain(false, true, (float)-outterBoundSimDif);
	funcConfSim2StateDev1.setKandD((float)0, (float)0);
	confSim2StateDev.addLinearFunction(&funcConfSim2StateDev1);
	LinearFunction funcConfSim2StateDev2;
	funcConfSim2StateDev2.setDomain(true, (float)-outterBoundSimDif, true, (float)-innerBoundSimDif);
	funcConfSim2StateDev2.setKandD((float)-outterBoundSimDif, (float)0, (float)-innerBoundSimDif, (float)1);
	confSim2StateDev.addLinearFunction(&funcConfSim2StateDev2);
	LinearFunction funcConfSim2StateDev3;
	funcConfSim2StateDev3.setDomain(true, (float)-innerBoundSimDif, true, (float)innerBoundSimDif);
	funcConfSim2StateDev3.setKandD((float)0, (float)1);
	confSim2StateDev.addLinearFunction(&funcConfSim2StateDev3);
	LinearFunction funcConfSim2StateDev4;
	funcConfSim2StateDev4.setDomain(true, (float)innerBoundSimDif, true, (float)outterBoundSimDif);
	funcConfSim2StateDev4.setKandD((float)innerBoundSimDif, (float)1, (float)outterBoundSimDif, (float)0);
	confSim2StateDev.addLinearFunction(&funcConfSim2StateDev4);
	LinearFunction funcConfSim2StateDev5;
	funcConfSim2StateDev5.setDomain(true, (float)outterBoundSimDif, false);
	funcConfSim2StateDev5.setKandD((float)0, (float)0);
	confSim2StateDev.addLinearFunction(&funcConfSim2StateDev5);
	
	//ANOTHER STATE DEVIATION
	LinearFunctionBlock confDif2StateDev("funcBlock:confDif2StateDev");
	LinearFunction funcConfDif2StateDev1;
	funcConfDif2StateDev1.setDomain(false, true, (float)-outterBoundSimDif);
	funcConfDif2StateDev1.setKandD((float)0, (float)1);
	confDif2StateDev.addLinearFunction(&funcConfDif2StateDev1);
	LinearFunction funcConfDif2StateDev2;
	funcConfDif2StateDev2.setDomain(true, (float)-outterBoundSimDif, true, (float)-innerBoundSimDif);
	funcConfDif2StateDev2.setKandD((float)-outterBoundSimDif, (float)1, (float)-innerBoundSimDif, (float)0);
	confDif2StateDev.addLinearFunction(&funcConfDif2StateDev2);
	LinearFunction funcConfDif2StateDev3;
	funcConfDif2StateDev3.setDomain(true, (float)-innerBoundSimDif, true, (float)innerBoundSimDif);
	funcConfDif2StateDev3.setKandD((float)0, (float)0);
	confDif2StateDev.addLinearFunction(&funcConfDif2StateDev3);
	LinearFunction funcConfDif2StateDev4;
	funcConfDif2StateDev4.setDomain(true, (float)innerBoundSimDif, true, (float)outterBoundSimDif);
	funcConfDif2StateDev4.setKandD((float)innerBoundSimDif, (float)0, (float)outterBoundSimDif, (float)1);
	confDif2StateDev.addLinearFunction(&funcConfDif2StateDev4);
	LinearFunction funcConfDif2StateDev5;
	funcConfDif2StateDev5.setDomain(true, (float)outterBoundSimDif, false);
	funcConfDif2StateDev5.setKandD((float)0, (float)1);
	confDif2StateDev.addLinearFunction(&funcConfDif2StateDev5);

	//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)length);
	funcConfSim2StateTime2.setKandD((float)0, (float)0, (float)length, (float)1);
	confSim2StateTime.addLinearFunction(&funcConfSim2StateTime2);
	LinearFunction funcConfSim2StateTime3;
	funcConfSim2StateTime3.setDomain(true, (float)length, false);
	funcConfSim2StateTime3.setKandD((float)0, (float)1);
	confSim2StateTime.addLinearFunction(&funcConfSim2StateTime3);

	//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)length);
	funcConfDif2StateTime2.setKandD((float)0, (float)1, (float)length, (float)0);
	confDif2StateTime.addLinearFunction(&funcConfDif2StateTime2);
	LinearFunction funcConfDif2StateTime3;
	funcConfDif2StateTime3.setDomain(true, (float)length, false);
	funcConfDif2StateTime3.setKandD((float)0, (float)0);
	confDif2StateTime.addLinearFunction(&funcConfDif2StateTime3);

	/************************ FunctionBlocks Val/Inv State (NEU) ************************/

	//VALID STATE DEVIATION
	LinearFunctionBlock confValidStateDev("funcBlock:confValidStateDev");
	LinearFunction funcConfValidStateDev1;
	funcConfValidStateDev1.setDomain(false, true, (float)-outterBoundSimDif);
	funcConfValidStateDev1.setKandD((float)0, (float)0);
	confValidStateDev.addLinearFunction(&funcConfValidStateDev1);
	LinearFunction funcConfValidStateDev2;
	funcConfValidStateDev2.setDomain(true, (float)-outterBoundSimDif, true, (float)-innerBoundSimDif);
	funcConfValidStateDev2.setKandD((float)-outterBoundSimDif, (float)0, (float)-innerBoundSimDif, (float)1);
	confValidStateDev.addLinearFunction(&funcConfValidStateDev2);
	LinearFunction funcConfValidStateDev3;
	funcConfValidStateDev3.setDomain(true, (float)-innerBoundSimDif, true, (float)innerBoundSimDif);
	funcConfValidStateDev3.setKandD((float)0, (float)1);
	confValidStateDev.addLinearFunction(&funcConfValidStateDev3);
	LinearFunction funcConfValidStateDev4;
	funcConfValidStateDev4.setDomain(true, (float)innerBoundSimDif, true, (float)outterBoundSimDif);
	funcConfValidStateDev4.setKandD((float)innerBoundSimDif, (float)1, (float)outterBoundSimDif, (float)0);
	confValidStateDev.addLinearFunction(&funcConfValidStateDev4);
	LinearFunction funcConfValidStateDev5;
	funcConfValidStateDev5.setDomain(true, (float)outterBoundSimDif, false);
	funcConfValidStateDev5.setKandD((float)0, (float)0);
	confValidStateDev.addLinearFunction(&funcConfValidStateDev5);
	
	//INVALID STATE DEVIATION
	LinearFunctionBlock confInvalidStateDev("funcBlock:confInvalidStateDev");
	LinearFunction funcConfInvalidStateDev1;
	funcConfInvalidStateDev1.setDomain(false, true, (float)-outterBoundSimDif);
	funcConfInvalidStateDev1.setKandD((float)0, (float)1);
	confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev1);
	LinearFunction funcConfInvalidStateDev2;
	funcConfInvalidStateDev2.setDomain(true, (float)-outterBoundSimDif, true, (float)-innerBoundSimDif);
	funcConfInvalidStateDev2.setKandD((float)-outterBoundSimDif, (float)1, (float)-innerBoundSimDif, (float)0);
	confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev2);
	LinearFunction funcConfInvalidStateDev3;
	funcConfInvalidStateDev3.setDomain(true, (float)-innerBoundSimDif, true, (float)innerBoundSimDif);
	funcConfInvalidStateDev3.setKandD((float)0, (float)0);
	confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev3);
	LinearFunction funcConfInvalidStateDev4;
	funcConfInvalidStateDev4.setDomain(true, (float)innerBoundSimDif, true, (float)outterBoundSimDif);
	funcConfInvalidStateDev4.setKandD((float)innerBoundSimDif, (float)0, (float)outterBoundSimDif, (float)1);
	confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev4);
	LinearFunction funcConfInvalidStateDev5;
	funcConfInvalidStateDev5.setDomain(true, (float)outterBoundSimDif, false);
	funcConfInvalidStateDev5.setKandD((float)0, (float)1);
	confInvalidStateDev.addLinearFunction(&funcConfInvalidStateDev5);
	
	//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)length);				//10
	funcConfValidStateTime2.setKandD((float)0, (float)0, (float)length, (float)1);
	confValidStateTime.addLinearFunction(&funcConfValidStateTime2);
	LinearFunction funcConfValidStateTime3;
	funcConfValidStateTime3.setDomain(true, (float)length, false);
	funcConfValidStateTime3.setKandD((float)0, (float)1);
	confValidStateTime.addLinearFunction(&funcConfValidStateTime3);

	//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)length);
	funcConfInvalidStateTime2.setKandD((float)0, (float)1, (float)length, (float)0);
	confInvalidStateTime.addLinearFunction(&funcConfInvalidStateTime2);
	LinearFunction funcConfInvalidStateTime3;
	funcConfInvalidStateTime3.setDomain(true, (float)length, false);
	funcConfInvalidStateTime3.setKandD((float)0, (float)0);
	confInvalidStateTime.addLinearFunction(&funcConfInvalidStateTime3);


	/********************************** Functions NOT OK **********************************/

	LinearFunctionBlock confStateDrifts("confidence:confStateDrifts");
	LinearFunction functionConfidenceDriftDeviation1;
	functionConfidenceDriftDeviation1.setDomain(false, true, (float)-outterBoundDRIFT);
	functionConfidenceDriftDeviation1.setKandD((float)0, (float)1);
	confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation1);
	LinearFunction functionConfidenceDriftDeviation2;
	functionConfidenceDriftDeviation2.setDomain(true, (float)-outterBoundDRIFT, true, (float)-innerBoundDRIFT);		
	functionConfidenceDriftDeviation2.setKandD((float)-outterBoundDRIFT, (float)1, (float)-innerBoundDRIFT, (float)0);
	confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation2);
	LinearFunction functionConfidenceDriftDeviation3;
	functionConfidenceDriftDeviation3.setDomain(true, (float)-innerBoundDRIFT, true, (float)innerBoundDRIFT);
	functionConfidenceDriftDeviation3.setKandD((float)0, (float)0);
	confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation3);
	LinearFunction functionConfidenceDriftDeviation4;
	functionConfidenceDriftDeviation4.setDomain(true, (float)innerBoundDRIFT, true, (float)outterBoundDRIFT);
	functionConfidenceDriftDeviation4.setKandD((float)innerBoundDRIFT, (float)0, (float)outterBoundDRIFT, (float)1);
	confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation4);
	LinearFunction functionConfidenceDriftDeviation5;
	functionConfidenceDriftDeviation5.setDomain(true, (float)outterBoundDRIFT, false);
	functionConfidenceDriftDeviation5.setKandD((float)0, (float)1);
	confStateDrifts.addLinearFunction(&functionConfidenceDriftDeviation5);

	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)boundBroken);
	functionConfidenceBroken2.setKandD((float)0, (float)0, (float)boundBroken, (float)1);
	confBroken.addLinearFunction(&functionConfidenceBroken2);
	LinearFunction functionConfidenceBroken3;
	functionConfidenceBroken3.setDomain(true, (float)boundBroken, false);
	functionConfidenceBroken3.setKandD((float)0, (float)1);
	confBroken.addLinearFunction(&functionConfidenceBroken3);


	/********************************** Mount Functions **********************************/
	
	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�������������������NER MACHEN
	a_viabilityMonitor.get_stateHandler()->DriftDeviation = &confStateDrifts;
	a_viabilityMonitor.get_stateHandler()->FuncBlockConfBrokenSamples = &confBroken;



	//create testbench
	printf("\nCreate Testbench\n");
	Testbench tb = create_testbench("testbench");

	//at 1% threshold - stable at ~6061
	//unsigned int ROW = 6040;
	unsigned int ROW = 2;


	//csv-data
	//TODO: (1) simplify constructor, (2) check CSV for number of rows and columns, (3) redesign create_CSVreaderModule function
	printf("\nCreate CSV Reader Modules\n");
	std::string filepath_stator_voltage;
	std::string filepath_stator_current;
	std::string filepath_speed;
	std::string filepath_electric_torque;
	std::string filepath_mechanical_torque;
	filepath_stator_voltage		= PATH_TO_CSV_DATA_FILES + FOLDERNAME_NORMAL_OPERATION + FILENAME_STATOR_VOLTAGE_ABSTRACTED;
	filepath_stator_current 	= PATH_TO_CSV_DATA_FILES + FOLDERNAME_NORMAL_OPERATION + FILENAME_STATOR_CURRENT_ABSTRACTED;
	filepath_speed 				= PATH_TO_CSV_DATA_FILES + FOLDERNAME_NORMAL_OPERATION + FILENAME_SPEED;
	filepath_electric_torque 	= PATH_TO_CSV_DATA_FILES + FOLDERNAME_NORMAL_OPERATION + FILENAME_ELECTROMACNTEIC_TORQUE;
	filepath_mechanical_torque 	= PATH_TO_CSV_DATA_FILES + FOLDERNAME_NORMAL_OPERATION + FILENAME_MECHANICAL_TORQUE;
	char* name_volt_csv_reader 	= "Stator Voltage CSV-Reader";
	char* name_curr_csv_reader 	= "Stator Current CSV-Reader";
	char* name_speed_csv_reader = "Speed CSV-Reader";
	char* name_el_torque_csv_reader = "Electromagnetic Torque CSV-Reader";
	char* name_me_torque_csv_reader = "Mechanical Torque CSV-Reader";
#ifdef MODE_NORMAL_UNCHANGED
#ifdef CSV_FILTERED
	//Normal_operation-Tm0 (filtered)
	CSVreaderModule csvr_statorVoltage 			= create_CSVreaderModule(name_volt_csv_reader, filepath_stator_voltage.c_str(), 2, ROW);
	CSVreaderModule csvr_statorCurrent			= create_CSVreaderModule(name_curr_csv_reader, filepath_stator_current.c_str(), 2, ROW);
	CSVreaderModule csvr_speed 					= create_CSVreaderModule(name_speed_csv_reader, filepath_speed.c_str(), 2, ROW);
	CSVreaderModule csvr_electromagneticTorque 	= create_CSVreaderModule(name_el_torque_csv_reader, filepath_electric_torque.c_str(), 2, ROW);
	CSVreaderModule csvr_mechanicalTorque 		= create_CSVreaderModule(name_me_torque_csv_reader, filepath_mechanical_torque.c_str(), 2, ROW);
#else
	//Normal_operation-Tm0  
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-Tm0\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-Tm0\\statorCurrent_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-Tm0\\speed.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-Tm0\\electromagneticTorque.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-Tm0\\mechanicalTorque.csv", 2, ROW);
#endif // CSV_FILTERED
#endif // MODE_NORMAL_UNCHANGED



#ifdef MODE_NORMAL_LOADCHANGE
#ifdef CSV_FILTERED
	/*
	//Normal_operation-changing load (filteredTwice)
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\mechanicalTorque.csv", 2, ROW);
	*/
	//Normal_operation-changing load (filteredOnce)
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\statorCurrent_abs_fil_once.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\speed_filtered_once.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\te_filtered_once.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\mechanicalTorque.csv", 2, ROW);
#else
	//Normal_operation-Tm0  
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\statorCurrent_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\speed.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\electromagneticTorque.csv", 2, ROW);
	//CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\mechanicalTorque_fil_quad.csv", 2, ROW);
	//CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\mechanicalTorque_fil_triple.csv", 2, ROW);
	//CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\mechanicalTorque_fil_twice.csv", 2, ROW);
	//CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\mechanicalTorque_fil_once.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Normal_operation-changing load\\mechanicalTorque.csv", 2, ROW);
#endif // CSV_FILTERED
#endif // MODE_NORMAL_UNCHANGED
	
#ifdef MODE_NORMAL_SPEEDCHANGE
#ifdef CSV_FILTERED
	//Change_of_speed (filtered)
	//CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\vsa_amp_abs_fil_twice.csv", 2, ROW);
	//CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\vsa_amp_abs_fil_once.csv", 2, ROW);
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\mechanicalTorque.csv", 2, ROW);
	CSVreaderModule csvr_frequency = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\frequency.csv", 2, ROW);
#else
	//Change_of_speed
	//CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\vsa_amp_abs_fil_twice.csv", 2, ROW);
	//CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\vsa_amp_abs_fil_once.csv", 2, ROW);
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\statorCurrent_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\speed.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\electromagneticTorque.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\mechanicalTorque.csv", 2, ROW);
	CSVreaderModule csvr_frequency = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Change_of_speed\\frequency.csv", 2, ROW);
#endif // CSV_FILTERED
#endif // MODE_NORMAL_UNCHANGED


#ifdef MODE_DRIFT
#ifdef CSV_FILTERED
	/*
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Wear-out\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Wear-out\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\Wear-out\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Wear-out\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Wear-out\\mechanicalTorque.csv", 2, ROW);
	
	
	//Wear-out 10%
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-10pc\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-10pc\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-10pc\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-10pc\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-10pc\\mechanicalTorque.csv", 2, ROW);
	
	//Wear-out 20%
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-20pc\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-20pc\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-20pc\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-20pc\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-20pc\\mechanicalTorque.csv", 2, ROW);
	
	//Wear-out 4%
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-4pc\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-4pc\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-4pc\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-4pc\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-4pc\\mechanicalTorque.csv", 2, ROW);
	
	//Wear-out 5%
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-5pc\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-5pc\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-5pc\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-5pc\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-5pc\\mechanicalTorque.csv", 2, ROW);
	
	//Wear-out 6%
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-6pc\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-6pc\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-6pc\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-6pc\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-6pc\\mechanicalTorque.csv", 2, ROW);
	
	//Wear-out 7%
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-7pc\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-7pc\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-7pc\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-7pc\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-7pc\\mechanicalTorque.csv", 2, ROW);
	
	//Wear-out 8%
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-8pc\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-8pc\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-8pc\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-8pc\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-8pc\\mechanicalTorque.csv", 2, ROW);
	
	//Wear-out 9%
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-9pc\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-9pc\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-9pc\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-9pc\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-9pc\\mechanicalTorque.csv", 2, ROW);
	
	//Wear-out HedyehNew (original with less friction)
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-HedyehNew\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-HedyehNew\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-HedyehNew\\speed_filtered.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-HedyehNew\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\zusaetzlich\\Wearing-out-HedyehNew\\mechanicalTorque.csv", 2, ROW);
	
	
	//Wear-out 001 (DataSet_2)
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Samba_Dataset_2\\Wearing out-001\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Samba_Dataset_2\\Wearing out-001\\statorCurrent_abs_fil_twice.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\Samba_Dataset_2\\Wearing out-001\\speed_filtered_twice.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Samba_Dataset_2\\Wearing out-001\\te_filtered_twice.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Samba_Dataset_2\\Wearing out-001\\mechanicalTorque.csv", 2, ROW);

	//Wear-out 005 (DataSet_2)
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Samba_Dataset_2\\Wearing out-005\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Samba_Dataset_2\\Wearing out-005\\statorCurrent_abs_fil_twice.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\Samba_Dataset_2\\Wearing out-005\\speed_filtered_twice.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Samba_Dataset_2\\Wearing out-005\\te_filtered_twice.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Samba_Dataset_2\\Wearing out-005\\mechanicalTorque.csv", 2, ROW);
	*/
#else
	
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Wear-out\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Wear-out\\statorCurrent_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_speed = create_CSVreaderModule("Speed CSV-Reader", "C:\\csv-data\\sambamotor\\Wear-out\\speed.csv", 2, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Wear-out\\electromagneticTorque.csv", 2, ROW);
	CSVreaderModule csvr_mechanicalTorque = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Wear-out\\mechanicalTorque.csv", 2, ROW);
#endif // CSV_FILTERED
#endif // MODE_NORMAL_UNCHANGED

#ifdef MODE_BROKEN
#ifdef CSV_FILTERED
	//Bearing-defect 0nm
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent_1 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent_2 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\statorCurrent_abs_fil.csv", 3, ROW);
	CSVreaderModule csvr_statorCurrent_3 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\statorCurrent_abs_fil.csv", 4, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_vibration_1 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\vib1_filtered.csv", 2, ROW);
	CSVreaderModule csvr_vibration_2 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\vib2_filtered.csv", 2, ROW);
	CSVreaderModule csvr_vibration_3 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\vib3_filtered.csv", 2, ROW);
#else

	//Bearing-defect 0nm
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent_1 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\statorCurrent_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent_2 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\statorCurrent_abstracted.csv", 3, ROW);
	CSVreaderModule csvr_statorCurrent_3 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\OR_0nm_2\\statorCurrent_abstracted.csv", 4, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\source\\OR_0nm_2.csv", 5, ROW);
	CSVreaderModule csvr_vibration_1 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\source\\OR_0nm_2.csv", 6, ROW);
	CSVreaderModule csvr_vibration_2 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\source\\OR_0nm_2.csv", 7, ROW);
	CSVreaderModule csvr_vibration_3 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\source\\OR_0nm_2.csv", 8, ROW);

#endif // CSV_FILTERED
#endif // MODE_NORMAL_UNCHANGED
	
	
#ifdef MODE_HEALTHY
#ifdef CSV_FILTERED
	//Bearing-defect 0nm
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent_1 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent_2 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\statorCurrent_abs_fil.csv", 3, ROW);
	CSVreaderModule csvr_statorCurrent_3 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\statorCurrent_abs_fil.csv", 4, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_vibration_1 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\vib1_filtered.csv", 2, ROW);
	CSVreaderModule csvr_vibration_2 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\vib2_filtered.csv", 2, ROW);
	CSVreaderModule csvr_vibration_3 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\vib3_filtered.csv", 2, ROW);
#else

	printf("DATASET NOT AVAILABLE -> therefore filteres data loaded\n");
	getchar();

	//Bearing-defect 0nm
	CSVreaderModule csvr_statorVoltage = create_CSVreaderModule("Stator Voltage CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\statorVoltage_abstracted.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent_1 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\statorCurrent_abs_fil.csv", 2, ROW);
	CSVreaderModule csvr_statorCurrent_2 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\statorCurrent_abs_fil.csv", 3, ROW);
	CSVreaderModule csvr_statorCurrent_3 = create_CSVreaderModule("Stator Current CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\statorCurrent_abs_fil.csv", 4, ROW);
	CSVreaderModule csvr_electromagneticTorque = create_CSVreaderModule("Electromagnetic Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\te_filtered.csv", 2, ROW);
	CSVreaderModule csvr_vibration_1 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\vib1_filtered.csv", 2, ROW);
	CSVreaderModule csvr_vibration_2 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\vib2_filtered.csv", 2, ROW);
	CSVreaderModule csvr_vibration_3 = create_CSVreaderModule("Mechanical Torque CSV-Reader", "C:\\csv-data\\sambamotor\\Anomaly-bearing_defect\\Healthy_0nm_2\\vib3_filtered.csv", 2, ROW);
	

#endif // CSV_FILTERED
#endif // MODE_HEALTHY




#ifdef MODE_NORMAL_SPEEDCHANGE
	Agent a_frequency = create_agent("Frequency");
	setWorkingCycleOfAgent(&a_frequency, workingCycle);
	Sensor s_frequency = create_sensor("Frequency");
	setWorkingCycleOfSensor(&s_frequency, workingCycle);
	Channel c_sa_frequency = create_channel("Frequency (SA)", 0);
	Channel c_aa_frequency = create_channel("Frequency (AA-UP)", MAX_BUFFER_LENGTH);
	mount_sensorInAgent(&a_frequency, &s_frequency, &c_sa_frequency);
	mount_agentInAgent(&a_viabilityMonitor, &a_frequency, &c_aa_frequency);
	registerSlaveAgentAsInputVariableInStateHandler(&a_viabilityMonitor, &c_aa_frequency);
	register_agentInTestbench(&tb, &a_frequency);
	register_sensorInTestbench(&tb, &s_frequency, &csvr_frequency);
	register_channelInTestbench(&tb, &c_sa_frequency);
	register_channelInTestbench(&tb, &c_aa_frequency);
#endif // MODE_NORMAL_SPEEDCHANGE

	
#if defined(MODE_BROKEN) || defined(MODE_HEALTHY)
	//register agents
	printf("\nRegister Agents in Testbench\n");
	//TODO: "Test Bench" not "Testbench"
	register_agentInTestbench(&tb, &a_statorVoltage);
	register_agentInTestbench(&tb, &a_statorCurrent_1);
	register_agentInTestbench(&tb, &a_statorCurrent_2);
	register_agentInTestbench(&tb, &a_statorCurrent_3);
	register_agentInTestbench(&tb, &a_electromagneticTorque);
	register_agentInTestbench(&tb, &a_vibration_1);
	register_agentInTestbench(&tb, &a_vibration_2);
	register_agentInTestbench(&tb, &a_vibration_3);
	register_agentInTestbench(&tb, &a_viabilityMonitor);

	//register sensors with their csv-readers
	printf("\nRegister Sensors in Testbench\n");
	register_sensorInTestbench(&tb, &s_statorVoltage, &csvr_statorVoltage);
	register_sensorInTestbench(&tb, &s_statorCurrent_1, &csvr_statorCurrent_1);
	register_sensorInTestbench(&tb, &s_statorCurrent_2, &csvr_statorCurrent_2);
	register_sensorInTestbench(&tb, &s_statorCurrent_3, &csvr_statorCurrent_3);
	register_sensorInTestbench(&tb, &s_electromagneticTorque, &csvr_electromagneticTorque);
	register_sensorInTestbench(&tb, &s_vibration_1, &csvr_vibration_1);
	register_sensorInTestbench(&tb, &s_vibration_2, &csvr_vibration_2);
	register_sensorInTestbench(&tb, &s_vibration_3, &csvr_vibration_3);

	//register sensor channels
	printf("\nRegister Channels in Testbench\n");
	register_channelInTestbench(&tb, &c_sa_statorVoltage);
	register_channelInTestbench(&tb, &c_sa_statorCurrent_1);
	register_channelInTestbench(&tb, &c_sa_statorCurrent_2);
	register_channelInTestbench(&tb, &c_sa_statorCurrent_3);
	register_channelInTestbench(&tb, &c_sa_electromagneticTorque);
	register_channelInTestbench(&tb, &c_sa_vibration_1);
	register_channelInTestbench(&tb, &c_sa_vibration_2);
	register_channelInTestbench(&tb, &c_sa_vibration_3);
	register_channelInTestbench(&tb, &c_aa_statorVoltage);
	register_channelInTestbench(&tb, &c_aa_statorCurrent_1);
	register_channelInTestbench(&tb, &c_aa_statorCurrent_2);
	register_channelInTestbench(&tb, &c_aa_statorCurrent_3);
	register_channelInTestbench(&tb, &c_aa_electromagneticTorque);
	register_channelInTestbench(&tb, &c_aa_vibration_1);
	register_channelInTestbench(&tb, &c_aa_vibration_2);
	register_channelInTestbench(&tb, &c_aa_vibration_3);
#else
	//No bearing defect
	//register agents
	printf("\nRegister Agents in Testbench\n");
	//TODO: "Test Bench" not "Testbench"
	register_agentInTestbench(&tb, &a_statorVoltage);
	register_agentInTestbench(&tb, &a_statorCurrent);
	register_agentInTestbench(&tb, &a_speed);
	register_agentInTestbench(&tb, &a_electromagneticTorque);
	register_agentInTestbench(&tb, &a_mechanicalTorque);
	register_agentInTestbench(&tb, &a_viabilityMonitor);

	//register sensors with their csv-readers
	printf("\nRegister Sensors in Testbench\n");
	register_sensorInTestbench(&tb, &s_statorVoltage, &csvr_statorVoltage);
	register_sensorInTestbench(&tb, &s_statorCurrent, &csvr_statorCurrent);
	register_sensorInTestbench(&tb, &s_speed, &csvr_speed);
	register_sensorInTestbench(&tb, &s_electromagneticTorque, &csvr_electromagneticTorque);
	register_sensorInTestbench(&tb, &s_mechanicalTorque, &csvr_mechanicalTorque);

	//register sensor channels
	printf("\nRegister Channels in Testbench\n");
	register_channelInTestbench(&tb, &c_sa_statorVoltage);
	register_channelInTestbench(&tb, &c_sa_statorCurrent);
	register_channelInTestbench(&tb, &c_sa_speed);
	register_channelInTestbench(&tb, &c_sa_electromagneticTorque);
	register_channelInTestbench(&tb, &c_sa_mechanicalTorque);
	register_channelInTestbench(&tb, &c_aa_statorVoltage);
	register_channelInTestbench(&tb, &c_aa_statorCurrent);
	register_channelInTestbench(&tb, &c_aa_speed);
	register_channelInTestbench(&tb, &c_aa_electromagneticTorque);
	register_channelInTestbench(&tb, &c_aa_mechanicalTorque);
#endif // !MODE_BROKEN

	printf("\n\nPress any key to start simulation...\n");
	getchar();
	

	//Start
	//TODO: read lenght of CSV-Files and pass this number to tb.simulate
#if defined (MODE_NORMAL_UNCHANGED) || defined(MODE_NORMAL_LOADCHANGE)
	tb.simulate(60000);
#endif // NORMAL_OPERATION_UNCHANGED || NORMAL_OPERATION_LOADCHANGE

#ifdef MODE_NORMAL_SPEEDCHANGE
	tb.simulate(20001);	//change speed
#endif // NORMAL_OERATION_SPEEDCHANGE

#ifdef MODE_DRIFT
	tb.simulate(100000);	//drift + load change (new)
#endif // MODE_DRIFT

#if defined(MODE_BROKEN) || defined(MODE_HEALTHY)
	tb.simulate(128000);	//bearingDefect
#endif // defined(MODE_BROKEN) || defined(MODE_HEALTHY)


	printf("\nSimulation has finished\n");
	getchar();
}