HVAC_M7_MODEL/Model_Task.c

//
// Created by cfif on 19.12.2025.
//
#include "Model_Task.h"
#include <SystemDelayInterface.h>
#include <CmsisRtosThreadUtils.h>
#include "HVAC_model.h"
#include "memory.h"
#include "SystemDelayInterface.h"

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

void ModelTask_Init(
        tModelTask *env,
        tLinTaskActuator *linTaskActuator1,
        tLinTaskActuator *linTaskActuator2,
        tLinTaskActuator *linTaskActuator3,
        tLoggerInterface *logger
) {
    HVAC_model_initialize();

    env->linTaskActuator1 = linTaskActuator1;
    env->linTaskActuator2 = linTaskActuator2;
    env->linTaskActuator3 = linTaskActuator3;

    env->access = osMutexNew(NULL);
    env->logger = logger;
    InitThreadAtrStatic(&env->thread.attr, "ModelTask", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
    env->thread.id = 0;
}

static bool setActuatorBusy(tModelTask *env) {


    if (env->triggerCommand1 == false) {


        for (uint8_t i = 0; i < env->linTaskActuator1->LIN_ISSR_ALL; ++i) {
            if (Actuator_Ch0_Command_Model.COM[i] != 0) {

                env->triggerCommand1 = true;

                memcpy(&env->triggerActuatorCmdBus_1, &Actuator_Ch0_Command_Model, sizeof(ActuatorCmdBus));

#if (LOG_LIN_ACTUATOR == 1)
#if (LOG_LIN1_ACTUATOR == 1)
                for (uint8_t j = 0; j < env->linTaskActuator1->LIN_ISSR_ALL; ++j) {
                    switch (Actuator_Ch0_Command_Model.COM[j]) {
                        case LIN_ACT_CFR_MOD: {
                            LoggerFormatTrace(LOGGER, LOG_SIGN,
                                              "LIN1 (ADR[%d] = %d): TRIGGERED COMMAND LIN_ACT_CFR_MOD (SET BUSY)", j,
                                              Actuator_Ch0_Command_Model.BUS_ADR[j])
                            break;
                        }
                        case LIN_ACT_CFR_INI: {
                            LoggerFormatTrace(LOGGER, LOG_SIGN,
                                              "LIN1 (ADR[%d] = %d): TRIGGERED COMMAND LIN_ACT_CFR_INI (SET BUSY)", j,
                                              Actuator_Ch0_Command_Model.BUS_ADR[j])
                            break;
                        }

                        case LIN_ACT_CFR_SET: {
                            LoggerFormatTrace(LOGGER, LOG_SIGN,
                                              "LIN1 (ADR[%d] = %d): TRIGGERED COMMAND LIN_ACT_CFR_SET (SET BUSY)", j,
                                              Actuator_Ch0_Command_Model.BUS_ADR[j])
                            break;
                        }

                        default: {
                            LoggerFormatError(LOGGER, LOG_SIGN,
                                              "LIN1 (ADR[%d] = %d): TRIGGERED COMMAND = %d UNKNOWN !!! (SET BUSY)", j,
                                              Actuator_Ch0_Command_Model.BUS_ADR[j], Actuator_Ch0_Command_Model.COM[i])
                        }
                    }
                }
#endif
#endif


                Actuator_Ch0_Status_Model.Busy = 1;
                break;
            }
        }
    }


    if (env->triggerCommand2 == false) {

        for (uint8_t i = 0; i < env->linTaskActuator2->LIN_ISSR_ALL; ++i) {
            if (Actuator_Ch1_Command_Model.COM[i] != 0) {

                env->triggerCommand2 = true;

                memcpy(&env->triggerActuatorCmdBus_2, &Actuator_Ch1_Command_Model, sizeof(ActuatorCmdBus));

#if (LOG_LIN_ACTUATOR == 1)
#if (LOG_LIN2_ACTUATOR == 1)

                for (uint8_t j = 0; j < env->linTaskActuator2->LIN_ISSR_ALL; ++j) {
                    switch (Actuator_Ch1_Command_Model.COM[j]) {
                        case LIN_ACT_CFR_MOD: {
                            LoggerFormatTrace(LOGGER, LOG_SIGN,
                                              "LIN2 (ADR[%d] = %d): TRIGGERED COMMAND LIN_ACT_CFR_MOD (SET BUSY)", j,
                                              Actuator_Ch1_Command_Model.BUS_ADR[j])
                            break;
                        }
                        case LIN_ACT_CFR_INI: {
                            LoggerFormatTrace(LOGGER, LOG_SIGN,
                                              "LIN2 (ADR[%d] = %d): TRIGGERED COMMAND LIN_ACT_CFR_INI (SET BUSY)", j,
                                              Actuator_Ch1_Command_Model.BUS_ADR[j])
                            break;
                        }

                        case LIN_ACT_CFR_SET: {
                            LoggerFormatTrace(LOGGER, LOG_SIGN,
                                              "LIN2 (ADR[%d] = %d): TRIGGERED COMMAND LIN_ACT_CFR_SET (SET BUSY)", j,
                                              Actuator_Ch1_Command_Model.BUS_ADR[j])
                            break;
                        }

                        default: {
                            LoggerFormatError(LOGGER, LOG_SIGN,
                                              "LIN2 (ADR[%d] = %d): TRIGGERED COMMAND = %d UNKNOWN !!! (SET BUSY)", j,
                                              Actuator_Ch1_Command_Model.BUS_ADR[j], Actuator_Ch1_Command_Model.COM[i])
                        }
                    }
                }
#endif
#endif


                Actuator_Ch1_Status_Model.Busy = 1;
                break;
            }
        }
    }


    if (env->triggerCommand3 == false) {

        for (uint8_t i = 0; i < env->linTaskActuator3->LIN_ISSR_ALL; ++i) {
            if (Actuator_Ch2_Command_Model.COM[i] != 0) {

                env->triggerCommand3 = true;

                memcpy(&env->triggerActuatorCmdBus_3, &Actuator_Ch2_Command_Model, sizeof(ActuatorCmdBus));

#if (LOG_LIN_ACTUATOR == 1)
#if (LOG_LIN3_ACTUATOR == 1)

                for (uint8_t j = 0; j < env->linTaskActuator3->LIN_ISSR_ALL; ++j) {
                    switch (Actuator_Ch2_Command_Model.COM[j]) {
                        case LIN_ACT_CFR_MOD: {
                            LoggerFormatTrace(LOGGER, LOG_SIGN,
                                              "LIN3 (ADR[%d] = %d): TRIGGERED COMMAND LIN_ACT_CFR_MOD (SET BUSY)", j,
                                              Actuator_Ch2_Command_Model.BUS_ADR[j])
                            break;
                        }
                        case LIN_ACT_CFR_INI: {
                            LoggerFormatTrace(LOGGER, LOG_SIGN,
                                              "LIN3 (ADR[%d] = %d): TRIGGERED COMMAND LIN_ACT_CFR_INI (SET BUSY)", j,
                                              Actuator_Ch2_Command_Model.BUS_ADR[j])
                            break;
                        }

                        case LIN_ACT_CFR_SET: {
                            LoggerFormatTrace(LOGGER, LOG_SIGN,
                                              "LIN3 (ADR[%d] = %d): TRIGGERED COMMAND LIN_ACT_CFR_SET (SET BUSY)", j,
                                              Actuator_Ch2_Command_Model.BUS_ADR[j])
                            break;
                        }

                        default: {
                            LoggerFormatError(LOGGER, LOG_SIGN,
                                              "LIN3 (ADR[%d] = %d): TRIGGERED COMMAND = %d UNKNOWN !!! (SET BUSY)", j,
                                              Actuator_Ch2_Command_Model.BUS_ADR[j], Actuator_Ch2_Command_Model.COM[i])
                        }
                    }
                }

#endif
#endif

                Actuator_Ch2_Status_Model.Busy = 1;
                break;
            }
        }
    }


    return false;
}

static _Noreturn void ModelTask_Thread(tModelTask *env) {
    for (;;) {
        if (osMutexAcquire(env->access, 1000) == osOK) {

            rtDW.t_now = SystemGetMs();

            HVAC_model_step();

            setActuatorBusy(env);

            env->isRunning = true;

            osMutexRelease(env->access);
        } else {
            LoggerErrorStatic(LOGGER, LOG_SIGN, "Access error ModelTask_Thread");
        }
        SystemDelayMs(100);
    }
}

void ModelTask_StartThread(tModelTask *env) {
    if (!env->thread.id) {
        env->thread.id = osThreadNew((osThreadFunc_t) (ModelTask_Thread), (void *) (env), &env->thread.attr);
    } else {
        osThreadResume(env->thread.id);
    }
}

void ModelTask_StopThread(tModelTask *env) {
    if (env->thread.id) {
        osThreadSuspend(env->thread.id);
    }
}