Page MenuHomePhorge
Files F1497852

configCAMforNewMotor.cpp
No OneTemporary
Actions

Size
23 KB
Referenced Files
None
Subscribers
None

configCAMforNewMotor.cpp
View Options

#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);
}

File Metadata

Mime Type
text/x-c
Expires
Sun, Mar 1, 10:18 PM (1 d, 14 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
287671
Default Alt Text
configCAMforNewMotor.cpp (23 KB)

Event Timeline