Page MenuHomePhorge

HistoryModule.cpp
No OneTemporary

Authored By
Unknown
Size
10 KB
Referenced Files
None
Subscribers
None

HistoryModule.cpp

This document is not UTF8. It was detected as JIS 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
Fri, Nov 20, 11:54 PM (4 h, 52 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
419425
Default Alt Text
HistoryModule.cpp (10 KB)

Event Timeline