VarTabDumpObserver/VarTabDumpObserver.c

//
// Created by cfif on 19.12.22.
//

#include <CmsisRtosThreadUtils.h>
#include "VarsTabDumpObserver.h"
#include "SystemDelayInterface.h"
#include "string.h"
#include "StorageOnFlashFlagchip.h"


#define LOGGER env->logger
#define LOG_SIGN "Storage"

void VarsTabDumpObserver_Init(
        tVarsTabDumpObserver *env,
        tStorageInterface *storageCalibInterface,
        tStorageInterface *storageParamInterface,
        uint32_t delay,
        void *dataCalib,
        void *dataParam,
        size_t sizeCalib,
        size_t sizeParam,
        uint8_t *trackableVarsTab,
        uint32_t trackableGroup,
        tLoggerInterface *logger
) {
    env->logger = logger;

    env->interfaceCalib = storageCalibInterface;
    env->interfaceParam = storageParamInterface;

    env->trackableVarsTab = trackableVarsTab;
    env->trackableGroup = trackableGroup;

    env->dataCalib = dataCalib;
    env->sizeCalib = sizeCalib;

    env->dataParam = dataParam;
    env->sizeParam = sizeParam;

    env->delay = delay;
    env->dumpAfter = 0;
    env->access = osMutexNew(NULL);
    env->accessDumper = osMutexNew(NULL);

    InitThreadAtrStatic(&env->thread.attr, "Data", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
    env->thread.id = 0;
}


bool VarsTabDumpObserverCalib_Load(tVarsTabDumpObserver *env) {

    if (osMutexAcquire(env->accessDumper, 1000) == osOK) {
        eStorageStatus dumpStatus = StorageLoad(env->interfaceCalib, env->dataCalib, env->sizeCalib);
        osMutexRelease(env->accessDumper);

        if (dumpStatus == STORAGE_ERR_DEVICE) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Calibration: ROM error")
            env->health = false;
            return false;
        } else if (dumpStatus == STORAGE_OK) {
            env->health = true;
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Calibrations: Data successfully loaded from ROM")
            return true;
        }
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Calibration: Data error when loading from ROM")
        return false;
    } else {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Calibration: ROM read error")
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Calibrations: Parallel access error")
        return false;
    }

}

bool VarsTabDumpObserverParam_Load(tVarsTabDumpObserver *env) {

    if (osMutexAcquire(env->accessDumper, 1000) == osOK) {
        eStorageStatus dumpStatus = StorageLoad(env->interfaceParam, env->dataParam, env->sizeParam);
        osMutexRelease(env->accessDumper);

        if (dumpStatus == STORAGE_ERR_DEVICE) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Parameters: ROM error")
            env->health = false;
            return false;
        } else if (dumpStatus == STORAGE_OK) {
            env->health = true;
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Parameters: Data successfully loaded from ROM")
            return true;
        }
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Parameters: Data error while loading from ROM")
        return false;
    } else {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Parameters: ROM read error.")
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Parameters: Concurrent access error")
        return false;
    }

}

bool VarsTabDumpObserverCalib_Dump(tVarsTabDumpObserver *env) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Calibrations: Attempting to write to ROM")

    tStorageOnFlashFlagchip *storageOnFlashChipsCheckClear = env->interfaceCalib->env;

    int isMainFlashPageAddressCheckClear = memcmp((uint8_t *) storageOnFlashChipsCheckClear->mainFlashPageAddress,
                                                  env->dataCalib, env->sizeCalib - 8);

    int isRecoveryFlashPageAddressCheckClear = memcmp(
            (uint8_t *) storageOnFlashChipsCheckClear->recoveryFlashPageAddress, env->dataCalib, env->sizeCalib -8);

    if ((isMainFlashPageAddressCheckClear == 0) && (isRecoveryFlashPageAddressCheckClear == 0)) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Calibrations: No need to write to ROM")
        return true;
    }

    if (osMutexAcquire(env->accessDumper, 1000) == osOK) {

        eStorageStatus result = StorageDump(env->interfaceCalib, env->dataCalib, env->sizeCalib);

        osMutexRelease(env->accessDumper);

        env->health = (result == STORAGE_OK);

        if (env->health) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Calibrations: Successfully written to ROM")
            return true;
        } else {
            LoggerErrorStatic(LOGGER, LOG_SIGN, "Calibration: ROM write error")
            if (result == STORAGE_ERR_DATA) {
                LoggerErrorStatic(LOGGER, LOG_SIGN, "Calibration: Checksum error")
            } else {
                LoggerErrorStatic(LOGGER, LOG_SIGN, "Calibration: ROM error")
            }
            return false;
        }

    } else {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Calibration: ROM write error")
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Calibrations: Parallel access error")
        return false;
    }
}


bool VarsTabDumpObserverParam_Dump(tVarsTabDumpObserver *env) {
    LoggerInfoStatic(LOGGER, LOG_SIGN, "Parameters: Attempting to write to ROM")

    tStorageOnFlashFlagchip *storageOnFlashChipsCheckClear = env->interfaceParam->env;

    int isMainFlashPageAddressCheckClear = memcmp((uint8_t *) storageOnFlashChipsCheckClear->mainFlashPageAddress,
                                                  env->dataParam, env->sizeParam - 8);

    int isRecoveryFlashPageAddressCheckClear = memcmp(
            (uint8_t *) storageOnFlashChipsCheckClear->recoveryFlashPageAddress, env->dataParam, env->sizeParam - 8);

    if ((isMainFlashPageAddressCheckClear == 0) && (isRecoveryFlashPageAddressCheckClear == 0)) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Parameters: No need to write to ROM")
        return true;
    }

    if (osMutexAcquire(env->accessDumper, 1000) == osOK) {

        eStorageStatus result = StorageDump(env->interfaceParam, env->dataParam, env->sizeParam);

        osMutexRelease(env->accessDumper);

        env->health = (result == STORAGE_OK);

        if (env->health) {
            LoggerInfoStatic(LOGGER, LOG_SIGN, "Parameters: Successfully written to ROM")
            return true;
        } else {
            LoggerErrorStatic(LOGGER, LOG_SIGN, "Parameters: Error writing to ROM")
            if (result == STORAGE_ERR_DATA) {
                LoggerErrorStatic(LOGGER, LOG_SIGN, "Parameters: Checksum error")
            } else {
                LoggerErrorStatic(LOGGER, LOG_SIGN, "Parameters: ROM error")
            }
            return false;
        }

    } else {
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Parameters: Error writing to ROM")
        LoggerErrorStatic(LOGGER, LOG_SIGN, "Parameters: Concurrency error")
        return false;
    }
}


static bool VarsTabDumpObserver_IsNowDumpRequired(tVarsTabDumpObserver *env) {
    return env->dumpAfter < SystemGetMs();
}

void VarsTabDumpObserver_RequireDump(tVarsTabDumpObserver *env) {
    if (osMutexAcquire(env->access, 1) == osOK) {
        env->dumpAfter = SystemGetMs() + env->delay;
        osMutexRelease(env->access);
    }
}

void DeviceStorageProcessing(tVarsTabDumpObserver *env) {
    if (env->trackableVarsTab) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "Changes in parameters detected, writing to ROM is required")
        VarsTabDumpObserver_RequireDump(env);
    }

    if (env->dumpAfter && VarsTabDumpObserver_IsNowDumpRequired(env)) {
        if (osMutexAcquire(env->access, 1) == osOK) {
            if (VarsTabDumpObserver_IsNowDumpRequired(env)) {
                VarsTabDumpObserverParam_Dump(env);
                env->dumpAfter = 0;
            }
            osMutexRelease(env->access);
        }
    }
}

static _Noreturn void VarsTabDumpObserver_Thread(tVarsTabDumpObserver *env) {
    for (;;) {
        DeviceStorageProcessing(env);
        SystemDelayMs(100);
    }
}

void VarsTabDumpObserver_StartThread(tVarsTabDumpObserver *env) {
    ThreadBlock_Start(env->thread, env, VarsTabDumpObserver_Thread);
}

void VarsTabDumpObserver_StopThread(tVarsTabDumpObserver *env) {
    ThreadBlock_Stop(env->thread);
}


void VarsTabDumpObserver_Flush(tVarsTabDumpObserver *env) {
    if (env->dumpAfter) {
        LoggerInfoStatic(LOGGER, LOG_SIGN, "There are changes, we write them to ROM")
        if (osMutexAcquire(env->access, 10000) == osOK) {
            VarsTabDumpObserverParam_Dump(env);
            env->dumpAfter = 0;
            osMutexRelease(env->access);
        }
    }
}