Testbench.cpp
No OneTemporary
Actions

Size

12 KB

Referenced Files

None

Subscribers

None

Testbench.cpp
View Options

	#include "Testbench.h"

	#include "printError.h"
	#include <stdio.h>

	#define MAXNUMOF_REGISTEREDCAGENTS 1000
	#define MAXNUMOF_REGISTEREDCHANNELS 1000
	#define MAXNUMOF_REGISTEREDSENSORS 1000

	using namespace std;

	void Testbench :: init_testbench() {
	maxNumOf_registeredAgents = MAXNUMOF_REGISTEREDCAGENTS;
	maxNumOf_registeredChannels = MAXNUMOF_REGISTEREDCHANNELS;
	maxNumOf_registeredSensors = MAXNUMOF_REGISTEREDSENSORS;
	}

	Testbench :: Testbench() {
	set_name(NO_NAME);
	}

	Testbench :: Testbench(const char* 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() < maxNumOf_registeredAgents) {
	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() < maxNumOf_registeredSensors) {
	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() < maxNumOf_registeredChannels) {
	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;
	}
	}

	void Testbench :: simulate(unsigned int rounds) {
	for(unsigned int sec=1; sec<=rounds; sec++) {

	printf("cycle %u\n", sec);

	//update sensor values
	for(auto &sensorSlot : vector_registeredSensors) {
	Sensor *sensor = sensorSlot->get_sensor();
	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();
	}
	}
	getchar();
	}
	}





	/*
	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_ix<num_of_registered_sensors; s_ix++) {
	csv_writer->write_field(registered_sensors[s_ix]->get_name());
	csv_writer->make_new_field();
	}

	for(unsigned int a_ix=0; a_ix<num_of_registered_agents; a_ix++) {

	csv_writer->write_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_ix<num_of_registered_agents-1; a_ix++) {
	registered_agents[a_ix] = registered_agents[a_ix+1];
	}
	num_of_registered_agents--;

	return true;
	}
	return false;
	}

	bool Testbench :: get_ix_of_agent(Agent agent, unsigned int agent_ix) {
	for(unsigned int a_ix=0; a_ix<num_of_registered_agents; a_ix++) {
	if(registered_agents[a_ix] == agent) {
	*agent_ix = a_ix;
	return true;
	}
	}
	return false;
	}


	//for sensors:
	unsigned int Testbench :: get_num_of_registered_sensors() {
	return num_of_registered_sensors;
	}

	bool Testbench :: register_sensor(Sensor* sensor) {
	if(num_of_registered_sensors < MAX_NUM_OF_SENSORS) {
	registered_sensors[num_of_registered_sensors] = sensor;
	num_of_registered_sensors++;
	return true;
	}
	return false;
	}

	bool Testbench :: register_sensor(Sensor* sensor, CSV_Reader *csvr) {
	if(num_of_registered_sensors < MAX_NUM_OF_SENSORS) {
	registered_sensors[num_of_registered_sensors] = sensor;
	registered_sensors_csvr[num_of_registered_sensors] = csvr;
	flag_sensor_has_csvr[num_of_registered_sensors] = true;

	num_of_registered_sensors++;
	return true;
	}

	return false;
	}

	bool Testbench :: deregister_sensor(Sensor* sensor) {
	unsigned int sensor_ix;

	if(get_ix_of_sensor(sensor, &sensor_ix)) {
	return deregister_sensor(sensor_ix);
	}

	return false;
	}

	bool Testbench :: deregister_sensor(unsigned int sensor_ix) {
	if(sensor_ix < num_of_registered_sensors) {
	for(unsigned int s_ix=sensor_ix; s_ix<num_of_registered_sensors-1; s_ix++) {
	registered_sensors[s_ix] = registered_sensors[s_ix+1];
	//todo: next 2 lines are untested - test then
	registered_sensors_csvr[s_ix] = registered_sensors_csvr[s_ix+1];
	flag_sensor_has_csvr[s_ix] = flag_sensor_has_csvr[s_ix+1];
	}
	num_of_registered_sensors--;

	return true;
	}
	return false;
	}

	bool Testbench :: get_ix_of_sensor(Sensor* sensor, unsigned int *sensor_ix) {
	for(unsigned int s_ix=0; s_ix<num_of_registered_sensors; s_ix++) {
	if(registered_sensors[s_ix] == sensor) {
	*sensor_ix = s_ix;
	return true;
	}
	}
	return false;
	}

	bool Testbench :: get_flag_sensor_has_csvr(unsigned int sensor_ix) {
	return flag_sensor_has_csvr[sensor_ix];
	}

	CSV_Reader* Testbench :: get_registered_sensors_csvr(unsigned int sensor_ix) {
	if(flag_sensor_has_csvr[sensor_ix]) {
	return registered_sensors_csvr[sensor_ix];
	}
	return NULL;
	}

	//TODO: test following function! ...until now it is untested
	CSV_Reader* Testbench :: get_registered_sensors_csvr(Sensor* sensor) {
	unsigned int sensor_ix;

	if(get_ix_of_sensor(sensor, &sensor_ix)) {
	if(flag_sensor_has_csvr[sensor_ix]) {
	return registered_sensors_csvr[sensor_ix];
	}
	}

	return NULL;
	}






	//for channels:
	unsigned int Testbench :: get_num_of_registered_channels() {
	return num_of_registered_channels;
	}

	bool Testbench :: register_channel(Channel* channel) {
	if(num_of_registered_channels < MAX_NUM_OF_CHANNELS) {
	registered_channels[num_of_registered_channels] = channel;
	num_of_registered_channels++;
	return true;
	}
	return false;
	}

	bool Testbench :: deregister_channel(Channel* channel) {
	unsigned int channel_ix;

	if(get_ix_of_channel(channel, &channel_ix)) {
	return deregister_channel(channel_ix);
	}

	return false;
	}

	bool Testbench :: deregister_channel(unsigned int channel_ix) {
	if(channel_ix < num_of_registered_channels) {
	for(unsigned int c_ix=channel_ix; c_ix<num_of_registered_channels-1; c_ix++) {
	registered_channels[channel_ix] = registered_channels[channel_ix+1];
	}
	num_of_registered_channels--;

	return true;
	}
	return false;
	}

	bool Testbench :: get_ix_of_channel(Channel* channel, unsigned int *channel_ix) {
	for(unsigned int c_ix=0; c_ix<num_of_registered_channels; c_ix++) {
	if(registered_channels[c_ix] == channel) {
	*channel_ix = c_ix;
	return true;
	}
	}
	return false;
	}

	bool Testbench :: register_csv_reader(CSV_Reader* csv_reader) {
	if(csv_reader != NULL) {
	this->csv_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;
	}
	*/

File Metadata

Mime Type: text/x-c++
Expires: Sun, Mar 1, 6:50 PM (18 h, 40 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 285891
Default Alt Text: Testbench.cpp (12 KB)

Testbench.cppNo OneTemporaryActions

Testbench.cppView Options

File Metadata

Event Timeline

Testbench.cpp
No OneTemporary
Actions

Testbench.cpp
View Options