embeddedLibrary/libraries/dataAcquisition.c

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>

// Variable definition

static float **readings;

int sensorsNumber;
int slidingWindowSize;
void initializeReadings(int numSensors, int windowSize) {
    readings = (float **)malloc(numSensors * sizeof(float *));
    if (readings == NULL) {
        perror("Failed to allocate memory for readings");
        exit(EXIT_FAILURE);
    }
    for (int i = 0; i < numSensors; i++) {
        readings[i] = (float *)calloc(windowSize, sizeof(float));
        if (readings[i] == NULL) {
            perror("Failed to allocate memory for sensor readings");
            exit(EXIT_FAILURE);
        }
    }
    // Assign sensorsNumber and slidingWindowSize
    setSensorsNumber(numSensors);
    setSlidingWindowSize(windowSize);
}

void freeReadings() {
    for (int i = 0; i < sensorsNumber; i++) {
        free(readings[i]);
    }
    free(readings);
}

typedef struct
{
    int sensorsNumber;
    int slidingWindowSize;
} dataAcquisition;


// Functions

// Get the number of sensors
int getSensorsNumber() {
    return sensorsNumber;
}

// Get the sliding window size
int getSlidingWindowSize() {
    return slidingWindowSize;
}

// Set the number of sensors
void setSensorsNumber(int number) {
    sensorsNumber = number;
}

// Set the sliding window size
void setSlidingWindowSize(int size) {
    slidingWindowSize = size;
}

// Control on the fullness of the sliding window
bool isFull(int sensorIndex) {
    for (int i = 0; i < slidingWindowSize; i++) {
        if (readings[sensorIndex][i] == 0) {
            return false;
        }
    }
    return true;
}

// Add a reading to the readings array
void addReading(float value, int sensorIndex) {
    if (isFull(sensorIndex)) {
        for (int i = 0; i < slidingWindowSize - 1; i++) {
            readings[sensorIndex][i] = readings[sensorIndex][i + 1];
        }
        readings[sensorIndex][slidingWindowSize - 1] = value;
    } else {
        for (int i = 0; i < slidingWindowSize; i++) {
            if (readings[sensorIndex][i] == 0) {
                readings[sensorIndex][i] = value;
                break;
            }

        }
    }
}

float getAverageOnSensor(int sensorIndex) {
    if(isFull(sensorIndex) == false){
        printf("The sliding window is not full\n");
        return 0;
    }
    else{
        float sum = 0;
        for (int i = 0; i < slidingWindowSize; i++) {
            sum += readings[sensorIndex][i];
        }
        return sum / slidingWindowSize;
    }
}

float getAverageOnAllSensors() {
    float sum = 0;
    for (int i = 0; i < sensorsNumber; i++) {
        sum += getAverageOnSensor(i);
    }
    return sum / sensorsNumber;
}

float getOverallAverage() {
    float sum = 0;
    int totalReadings = 0;
    for (int i = 0; i < sensorsNumber; i++) {
        if (!isFull(i)) {
            printf("The sliding window for sensor %d is not full\n", i);
            return 0;
        }
        for (int j = 0; j < slidingWindowSize; j++) {
            sum += readings[i][j];
            totalReadings++;
        }
    }
    return sum / totalReadings;
}

float getStandardDeviationOnSensor(int sensorIndex) {
    if(isFull(sensorIndex) == false){
        printf("The sliding window is not full\n");
        return 0;
    }
    else{
        float sum = 0;
        float average = getAverageOnSensor(sensorIndex);
        for (int i = 0; i < slidingWindowSize; i++) {
            sum += pow(readings[sensorIndex][i] - average, 2);
        }
        return sqrt(sum / slidingWindowSize);
    }
}

float getStandardDeviationOnAllSensors() {
    float sum = 0;
    for (int i = 0; i < sensorsNumber; i++) {
        sum += getStandardDeviationOnSensor(i);
    }
    return sum / sensorsNumber;
}

float getOverallStandardDeviation() {
    float sum = 0;
    int totalReadings = 0;
    for (int i = 0; i < sensorsNumber; i++) {
        if (!isFull(i)) {
            printf("The sliding window for sensor %d is not full\n", i);
            return 0;
        }
        for (int j = 0; j < slidingWindowSize; j++) {
            sum += pow(readings[i][j] - getOverallAverage(), 2);
            totalReadings++;
        }
    }
    return sqrt(sum / totalReadings);
}