HistoryModule.cpp
No OneTemporary
Actions

Size

10 KB

Referenced Files

None

Subscribers

None

HistoryModule.cpp
View Options

This document is not UTF8. It was detected as ISO-8859-1 (Latin 1) and converted to UTF8 for display.

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

	#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) {
	initHistoryModule();
	set_name(name);
	}

	bool HistoryModule :: set_maxHistoryLength(unsigned int length) {
	if(length <= MAX_HIST_LENGTH && length <= vHistory.max_size()) {
	this->historyLength = historyLength;
	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<history_max_length) {
	if(next_history_pointer < history_max_length) {
	history[next_history_pointer] = value;
	next_history_pointer++;
	}
	else {
	//if(flag_ring_memory) //TODO: Option(en) einbauen
	history[0] = value;
	next_history_pointer = 1;
	}
	}
	else {
	printf("Field %i of history array is out of range!\n", point);
	}
	}
	unsigned int History :: get_history(unsigned int point) {
	if(point<history_max_length) {
	return history[point];
	}
	else {
	printf("Field %i of history array is out of range!\n", point);
	return NULL;
	}
	}

	void History :: set_history_max_length(unsigned int max_length) {
	history_max_length = max_length;
	}
	unsigned int History :: get_history_max_length() {
	return history_max_length;
	}
	*/

File Metadata

Mime Type: text/x-c
Expires: Sat, May 30, 11:35 PM (12 h, 14 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 329970
Default Alt Text: HistoryModule.cpp (10 KB)

HistoryModule.cppNo OneTemporaryActions

HistoryModule.cppView Options

File Metadata

Event Timeline

HistoryModule.cpp
No OneTemporary
Actions

HistoryModule.cpp
View Options