HVAC_M7
/
HVAC_M7_DebugTesting
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Обновление

This commit is contained in:
cfif 2026-02-12 17:13:38 +03:00
parent ed877443a4
commit a02c48d203
5 changed files with 204 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
LinActuatorWork.c
View File

@ -2,54 +2,58 @@
// Created by cfif on 20.01.2026.
//
#include "LinActuatorWork.h"
/*
void LinActuatorWork(tMma *env) {
if (osMutexAcquire(env->linTaskActuator0.access, 5000) == osOK) {
#define LOG_SIGN "Lin"
#define LOGGER &env->slog.logger
void LinActuatorWork(tMma *env, tLinTaskActuator *linTaskActuator) {
if (osMutexAcquire(linTaskActuator->access, 5000) == osOK) {
// Если актуатор не занят
if (env->linTaskActuator0.busy == false) {
if (linTaskActuator->busy == false) {
for (uint8_t i = 0; i < LIN0_ISSR_ALL; ++i) {
for (uint8_t i = 0; i < linTaskActuator->LIN_ISSR_ALL; ++i) {
env->linTaskActuator0.linCommandActuator[i].POS = env->rtY_local.Out1.POS[i];
env->linTaskActuator0.linCommandActuator[i].BUS_ADR = env->rtY_local.Out1.BUS_ADR[i];
env->linTaskActuator0.linCommandActuator[i].MODE = env->rtY_local.Out1.MODE[i];
linTaskActuator->linCommandActuator[i].POS = env->controllerData_local.POS[i];
linTaskActuator->linCommandActuator[i].BUS_ADR = env->controllerData_local.BUS_ADR[i];
linTaskActuator->linCommandActuator[i].MODE = env->controllerData_local.MODE[i];
// Если команда выполнена
if (env->linTaskActuator0.linCommandActuator[i].COM == LIN_ACT_CFR_SUCCESSFUL) {
if (linTaskActuator->linCommandActuator[i].COM == LIN_ACT_CFR_SUCCESSFUL) {
#if (LOG_LIN_ACTUATOR == 1)
LoggerInfoStatic(LOGGER, LOG_TASK_ARB, "SUCCESSFUL COMMAND")
LoggerInfoStatic(LOGGER, LOG_SIGN, "SUCCESSFUL COMMAND")
#endif
// Установка входной команды в LIN_ACT_CFR_NONE
env->rtY_local.Out1.COM[i] = LIN_ACT_CFR_NONE;
env->controllerData_local.COM[i] = LIN_ACT_CFR_NONE;
}
env->linTaskActuator0.linCommandActuator[i].COM = env->rtY_local.Out1.COM[i];
env->linTaskActuator0.linCommandActuator[i].Stall_SET = env->rtY_local.Out1.Stall_SET[i];
env->linTaskActuator0.linCommandActuator[i].Lnoise_SET = env->rtY_local.Out1.Lnoise_SET[i];
env->linTaskActuator0.linCommandActuator[i].Autos_SET = env->rtY_local.Out1.Autos_SET[i];
env->linTaskActuator0.linCommandActuator[i].Speed_SET = env->rtY_local.Out1.Speed_SET[i];
env->linTaskActuator0.linCommandActuator[i].Coils_Stop_SET = env->rtY_local.Out1.Coils_Stop_SET[i];
linTaskActuator->linCommandActuator[i].COM = env->controllerData_local.COM[i];
linTaskActuator->linCommandActuator[i].Stall_SET = env->controllerData_local.Stall_SET[i];
linTaskActuator->linCommandActuator[i].Lnoise_SET = env->controllerData_local.Lnoise_SET[i];
linTaskActuator->linCommandActuator[i].Autos_SET = env->controllerData_local.Autos_SET[i];
linTaskActuator->linCommandActuator[i].Speed_SET = env->controllerData_local.Speed_SET[i];
linTaskActuator->linCommandActuator[i].Coils_Stop_SET = env->controllerData_local.Coils_Stop_SET[i];
env->rtU_local.in_CPOS_ALL_Ch0[i] = (int16_t) env->linTaskActuator0.linStateActuator[i].CPOS_ALL;
env->rtU_local.in_Act_Emrf_Slave_Ch0[i] = (int8_t) env->linTaskActuator0.linStateActuator[i].Emrf_Slave;
env->rtU_local.in_Mode_Slave_Ch0[i] = (int8_t) env->linTaskActuator0.linStateActuator[i].Mode_Slave;
env->rtU_local.in_Act_Err1_Supply_Ch0[i] = (int8_t) env->linTaskActuator0.linStateActuator[i].Error1_Supply_Slave;
env->rtU_local.in_Act_Err2_Communication_Ch0[i] = (int8_t) env->linTaskActuator0.linStateActuator[i].Error2_Communication_Slave;
env->rtU_local.in_Act_Err3_Temperature_Ch0[i] = (int8_t) env->linTaskActuator0.linStateActuator[i].Error3_Temperature_Slave;
env->rtU_local.in_Act_Err4_Permanent_Electrical_Ch0[i] = (int8_t) env->linTaskActuator0.linStateActuator[i].Error4_Permanent_Electrical_Slave;
env->rtU_local.in_Act_Stall_Slave_Ch0[i] = env->linTaskActuator0.linStateActuator[i].Stall_Slave;
env->rtU_local.in_Act_Reset_Ch0[i] = env->linTaskActuator0.linStateActuator[i].Reset_Slave;
env->controllerDataInput_local.in_CPOS_ALL_Ch0[i] = (int16_t) linTaskActuator->linStateActuator[i].CPOS_ALL;
env->controllerDataInput_local.in_Act_Emrf_Slave_Ch0[i] = (int8_t) linTaskActuator->linStateActuator[i].Emrf_Slave;
env->controllerDataInput_local.in_Mode_Slave_Ch0[i] = (int8_t) linTaskActuator->linStateActuator[i].Mode_Slave;
env->controllerDataInput_local.in_Act_Err1_Supply_Ch0[i] = (int8_t) linTaskActuator->linStateActuator[i].Error1_Supply_Slave;
env->controllerDataInput_local.in_Act_Err2_Communication_Ch0[i] = (int8_t) linTaskActuator->linStateActuator[i].Error2_Communication_Slave;
env->controllerDataInput_local.in_Act_Err3_Temperature_Ch0[i] = (int8_t) linTaskActuator->linStateActuator[i].Error3_Temperature_Slave;
env->controllerDataInput_local.in_Act_Err4_Permanent_Electrical_Ch0[i] = (int8_t) linTaskActuator->linStateActuator[i].Error4_Permanent_Electrical_Slave;
env->controllerDataInput_local.in_Act_Stall_Slave_Ch0[i] = linTaskActuator->linStateActuator[i].Stall_Slave;
env->controllerDataInput_local.in_Act_Reset_Ch0[i] = linTaskActuator->linStateActuator[i].Reset_Slave;
}
env->isActuatorWorkBusy = setBusy(&env->linTaskActuator0);
env->isActuatorWorkBusy = setBusy(linTaskActuator);
env->rtU_local.in_Error_Connect_Ch0 = env->linTaskActuator0.error_connect;
env->rtU_local.in_Busy_Ch0 = env->linTaskActuator0.busy;
env->in_Error_Connect_Ch0 = linTaskActuator->error_connect;
env->in_Busy_Ch0 = linTaskActuator->busy;
}
osMutexRelease(env->linTaskActuator0.access);
osMutexRelease(linTaskActuator->access);
}
@ -58,10 +62,10 @@ void LinActuatorWork(tMma *env) {
// Если принята команда
if (env->ModelTask.triggerCommand == true) {
#if (LOG_LIN_ACTUATOR == 1)
LoggerInfoStatic(LOGGER, LOG_TASK_ARB, "DETECT COMMAND")
LoggerInfoStatic(LOGGER, LOG_SIGN, "DETECT COMMAND")
#endif
//
env->rtU_local.in_Busy_Ch0 = 1;
env->in_Busy_Ch0 = 1;
}
// Если прията команда и актуатор не занят
@ -71,23 +75,26 @@ void LinActuatorWork(tMma *env) {
env->isActuatorWorkBusy = true;
// Сброс STALL в состоянии актуатор и локальном состоянии
resetStall(&env->linTaskActuator0, (uint8_t *) env->rtU_local.in_Act_Stall_Slave_Ch0);
// Копирование команд
for (uint8_t i = 0; i < 9; ++i) {
rtY.Out1.COM[i] = env->ModelTask.numCommand[i];
}
resetStall(linTaskActuator, (uint8_t *) env->controllerDataInput_local.in_Act_Stall_Slave_Ch0);
// ВЫХОД МОДЕЛИ (АКТУАТОР)
memcpy(&env->rtY_local.Out1, &rtY.Out1, sizeof(rtY.Out1));
//memcpy(&env->rtY_local.Out1, &controllerData, sizeof(rtY.Out1));
memcpy(&env->controllerData_local, &controllerData, sizeof(ActuatorCmdBus));
// Копирование команд
for (uint8_t i = 0; i < linTaskActuator->LIN_ISSR_ALL; ++i) {
env->controllerData_local.COM[i] = env->ModelTask.numCommand[i];
}
}
// ВХОДЫ МОДЕЛИ
memcpy(&rtU, &env->rtU_local, sizeof(ExtU));
memcpy(&rtDW.controllerDataInput, &env->controllerDataInput_local, sizeof(rtDW.controllerDataInput));
rtDW.Busy_Ch0 = env->in_Busy_Ch0;
rtDW.Error_Connect_Ch0 = env->in_Error_Connect_Ch0;
osMutexRelease(env->ModelTask.access);
}
}
*/

2
LinActuatorWork.h
View File

@ -7,6 +7,6 @@
#include "MainModesArbiter_Private.h"
void LinActuatorWork(tMma *env);
void LinActuatorWork(tMma *env, tLinTaskActuator *linTaskActuator);
#endif //HVAC_M7_LINACTUATORWORK_H

188
MainModesArbiter.c
View File

@ -5,6 +5,7 @@
#include "stdio.h"
#include "fc7xxx_driver_rgm.h"
#include "Model_actuator.h"
#include "LinActuatorWork.h"
#include "ADC_Temp_Table.h"
@ -112,14 +113,18 @@ void LoadDataInFromModel(tMma *env) {
if (env->adcTask0.ADC_isUpdate) {
env->adcTask0.ADC_isUpdate = false;
/*
temp1 = get_temperature_fast(env->adcTask0.ADC0_Data.Sensor_Ambient_Temp);
temp2 = get_temperature_from_adc(env->adcTask0.ADC0_Data.Sensor_Ambient_Temp, ALG_STEINHART);
env->rtDW.ADC_Data_Model.Sensor_Incar_Temp_FL = env->adcTask0.ADC0_Data.Sensor_Ambient_Temp;
memcpy(&env->ADC_Data_Model_local, &env->adcTask0.ADC0_Data, sizeof(env->adcTask0.ADC0_Data));
asm("nop");
LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "Temp1 = %d; Temp2 = %d; ADC = %d", temp1, (int16_t) (temp2 * 10.0f), env->adcTask0.ADC0_Data.Sensor_Ambient_Temp)
*/
// temp1 = get_temperature_fast(env->adcTask0.ADC0_Data.Sensor_Ambient_Temp);
// temp2 = get_temperature_from_adc(env->adcTask0.ADC0_Data.Sensor_Ambient_Temp, ALG_STEINHART);
//env->ADC_Data_Model_local.Sensor_Incar_Temp_FL = env->adcTask0.ADC0_Data.Sensor_Ambient_Temp;
// LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "Temp1 = %d; Temp2 = %d; ADC = %d", temp1, (int16_t) (temp2 * 10.0f), env->adcTask0.ADC0_Data.Sensor_Ambient_Temp)
// R1 = 91000 R2 = 20000 ((5 * (91000 + 20000)) / 20000 = 27.75 В)
// float U_IGN_CHECK = ((float) env->adcTask0.ADC0_Data.IGN_ANS * 27.75f) / 4095.0f;
@ -182,6 +187,9 @@ void LoadDataInFromModel(tMma *env) {
if (env->adcTask1.ADC_isUpdate) {
env->adcTask1.ADC_isUpdate = false;
memcpy(&env->ADC_Data_Model_local.VN7008AJ_DIAG_FrontLINActuatorPowerDriverAB, &env->adcTask1.ADC1_Data, sizeof(env->adcTask1.ADC1_Data));
asm("nop");
// R1 = 91000 R2 = 16000 ((5 * (91000 + 16000)) / 16000 = 33.4375 В)
// float U_PBATT_CHECK = ((float) env->adcTask1.ADC1_Data.PBATT_CHECK * 33.4375f) / 4095.0f;
// LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "U_PBATT_CHECK = %f", U_PBATT_CHECK)
@ -212,8 +220,14 @@ void LoadDataInFromModel(tMma *env) {
}
if (osMutexAcquire(env->ModelTask.access, 5000) == osOK) {
GpioPinGet(&env->gpios->power.BTS4175SGAXUMA1_ReservePowerOutput.ST_ReservePower);
GpioPinGet(&env->gpios->power.BTS4175SGAXUMA1_ShutOFFValveBatteryChiller.ST_BATTChiller);
GpioPinGet(&env->gpios->EmergencyAirCleanSwitch);
GpioPinGet(&env->gpios->FireExtinguishSwitch);
rtDW.t_now = GetSystemTick();
memcpy(&rtDW, &env->rtDW.ADC_Data_Model, sizeof(rtDW.ADC_Data_Model));
memcpy(&rtDW.ADC_Data_Model, &env->ADC_Data_Model_local, sizeof(rtDW.ADC_Data_Model));
if (env->ModelTask.isUpdate) {
env->ModelTask.isUpdate = false;
@ -222,10 +236,14 @@ void LoadDataInFromModel(tMma *env) {
osMutexRelease(env->ModelTask.access);
}
}
static _Noreturn void Mma_Thread(tMma *env) {
uint8_t step = 0;
bool busy = false;
// Запуск устройства
Mma_InitStage(env);
@ -266,12 +284,11 @@ static _Noreturn void Mma_Thread(tMma *env) {
env->pwms->pwmRearReservedIo.setActivePercent(env->pwms->pwmRearReservedIo.env, 50);
for (;;) {
/*
SystemDelayMs(10);
uint8_t pwm1 = env->pwms->pwmFrontCaptureIO.getPwm(env->pwms->pwmFrontCaptureIO.env);
LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Front) = %d", pwm1)
SystemDelayMs(10);
uint8_t pwm2 = env->pwms->pwmRearCaptureIO.getPwm(env->pwms->pwmRearCaptureIO.env);
LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Rear) = %d", pwm2)
@ -279,19 +296,19 @@ static _Noreturn void Mma_Thread(tMma *env) {
SystemDelayMs(10);
uint8_t pwm3 = env->pwms->pwmFrontCaptureIO.getPwm(env->pwms->pwmFrontReservedCaptureIO.env);
LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Front Reserve) = %d", pwm3)
LoadDataInFromModel(env);
SystemDelayMs(10);
uint8_t pwm4 = env->pwms->pwmRearCaptureIO.getPwm(env->pwms->pwmRearReservedCaptureIO.env);
LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Rear Reserve) = %d", pwm4)
*/
LoadDataInFromModel(env);
// LinActuatorWork(env, &env->linTaskActuator1);
SystemDelayMs(500);
SystemDelayMs(100);
GpioPinToggle(&env->gpios->led.LED_G);
SystemDelayMs(500);
SystemDelayMs(100);
/*
@ -317,10 +334,13 @@ static _Noreturn void Mma_Thread(tMma *env) {
*/
/*
if (osMutexAcquire(env->linTaskActuator0.access, 5000) == osOK) {
uint8_t local[9];
tLinTaskActuator *linTaskActuator = &env->linTaskActuator2;
if ((env->linTaskActuator0.linCommandActuator[0].COM == LIN_ACT_CFR_SUCCESSFUL) ||
(env->linTaskActuator0.linCommandActuator[0].COM == LIN_ACT_CFR_NONE)) {
if (osMutexAcquire(linTaskActuator->access, 5000) == osOK) {
if ((linTaskActuator->linCommandActuator[0].COM == LIN_ACT_CFR_SUCCESSFUL) ||
(linTaskActuator->linCommandActuator[0].COM == LIN_ACT_CFR_NONE)) {
busy = true;
}
@ -330,49 +350,48 @@ static _Noreturn void Mma_Thread(tMma *env) {
switch (step) {
case 0: {
resetStall(&env->linTaskActuator0);
resetStall(linTaskActuator, local);
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_MOD;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].MODE = LIN_MODE_STOP;
linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_MOD;
linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
linTaskActuator->linCommandActuator[0].MODE = LIN_MODE_STOP;
++step;
break;
}
case 1: {
resetStall(&env->linTaskActuator0);
resetStall(linTaskActuator, local);
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_INI;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].POS = 6000;
linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_INI;
linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
linTaskActuator->linCommandActuator[0].POS = 6000;
++step;
break;
}
case 2: {
resetStall(linTaskActuator, local);
resetStall(&env->linTaskActuator0);
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_MOD;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].MODE = LIN_MODE_NORMAL;
linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_MOD;
linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
linTaskActuator->linCommandActuator[0].MODE = LIN_MODE_NORMAL;
++step;
break;
}
case 3: {
resetStall(&env->linTaskActuator0);
resetStall(linTaskActuator, local);
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_SET;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].POS = 0;
env->linTaskActuator0.linCommandActuator[0].Stall_SET = 1;
env->linTaskActuator0.linCommandActuator[0].Lnoise_SET = 0;
env->linTaskActuator0.linCommandActuator[0].Autos_SET = 1;
env->linTaskActuator0.linCommandActuator[0].Speed_SET = 3;
env->linTaskActuator0.linCommandActuator[0].Coils_Stop_SET = 0;
linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_SET;
linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
linTaskActuator->linCommandActuator[0].POS = 0;
linTaskActuator->linCommandActuator[0].Stall_SET = 1;
linTaskActuator->linCommandActuator[0].Lnoise_SET = 0;
linTaskActuator->linCommandActuator[0].Autos_SET = 1;
linTaskActuator->linCommandActuator[0].Speed_SET = 3;
linTaskActuator->linCommandActuator[0].Coils_Stop_SET = 0;
++step;
@ -380,10 +399,29 @@ static _Noreturn void Mma_Thread(tMma *env) {
}
case 4: {
SystemDelayMs(10000);
//SystemDelayMs(10000);
for (uint32_t i = 0; i < 100; ++i) {
if (osMutexAcquire(env->adcTask1.access, 1000) == osOK) {
if (env->adcTask1.ADC_isUpdate) {
env->adcTask1.ADC_isUpdate = false;
VN7008AJ(env, "VN7008AJ_FrontLINActuatorPowerDriverAB",
env->adcTask1.ADC1_Data.VN7008AJ_FrontLINActuatorPowerDriverAB);
}
osMutexRelease(env->adcTask1.access);
}
SystemDelayMs(100);
}
asm("nop");
++step;
//if (env->linTaskActuator0.linStateActuator[7].CPOS_ALL == 0) {
//if (linTaskActuator->linStateActuator[7].CPOS_ALL == 0) {
// ++step;
//}
break;
@ -391,11 +429,11 @@ static _Noreturn void Mma_Thread(tMma *env) {
case 5: {
resetStall(&env->linTaskActuator0);
resetStall(linTaskActuator, local);
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_INI;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].POS = 0;
linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_INI;
linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
linTaskActuator->linCommandActuator[0].POS = 0;
++step;
break;
@ -403,16 +441,16 @@ static _Noreturn void Mma_Thread(tMma *env) {
case 6: {
resetStall(&env->linTaskActuator0);
resetStall(linTaskActuator, local);
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_SET;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].POS = 6000;
env->linTaskActuator0.linCommandActuator[0].Stall_SET = 1;
env->linTaskActuator0.linCommandActuator[0].Lnoise_SET = 0;
env->linTaskActuator0.linCommandActuator[0].Autos_SET = 1;
env->linTaskActuator0.linCommandActuator[0].Speed_SET = 3;
env->linTaskActuator0.linCommandActuator[0].Coils_Stop_SET = 0;
linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_SET;
linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
linTaskActuator->linCommandActuator[0].POS = 6000;
linTaskActuator->linCommandActuator[0].Stall_SET = 1;
linTaskActuator->linCommandActuator[0].Lnoise_SET = 0;
linTaskActuator->linCommandActuator[0].Autos_SET = 1;
linTaskActuator->linCommandActuator[0].Speed_SET = 3;
linTaskActuator->linCommandActuator[0].Coils_Stop_SET = 0;
++step;
@ -420,20 +458,54 @@ static _Noreturn void Mma_Thread(tMma *env) {
}
case 7: {
SystemDelayMs(10000);
//SystemDelayMs(10000);
for (uint32_t i = 0; i < 100; ++i) {
if (osMutexAcquire(env->adcTask1.access, 1000) == osOK) {
if (env->adcTask1.ADC_isUpdate) {
env->adcTask1.ADC_isUpdate = false;
VN7008AJ(env, "VN7008AJ_FrontLINActuatorPowerDriverAB",
env->adcTask1.ADC1_Data.VN7008AJ_FrontLINActuatorPowerDriverAB);
}
osMutexRelease(env->adcTask1.access);
}
SystemDelayMs(100);
}
asm("nop");
++step;
//if (env->linTaskActuator0.linStateActuator[7].CPOS_ALL >= 6000) {
//if (linTaskActuator->linStateActuator[7].CPOS_ALL >= 6000) {
// ++step;
//}
break;
}
case 8: {
if (env->linTaskActuator0.linStateActuator[7].CPOS_ALL >= 8000) {
if (linTaskActuator->linStateActuator[7].CPOS_ALL >= 8000) {
++step;
}
if (osMutexAcquire(env->adcTask1.access, 1000) == osOK) {
if (env->adcTask1.ADC_isUpdate) {
env->adcTask1.ADC_isUpdate = false;
VN7008AJ(env, "VN7008AJ_FrontLINActuatorPowerDriverAB",
env->adcTask1.ADC1_Data.VN7008AJ_FrontLINActuatorPowerDriverAB);
}
osMutexRelease(env->adcTask1.access);
}
break;
}
@ -441,12 +513,12 @@ static _Noreturn void Mma_Thread(tMma *env) {
}
}
}
osMutexRelease(env->linTaskActuator0.access);
osMutexRelease(linTaskActuator->access);
}
LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "Step = %d", step)
*/
*/

17
MainModesArbiter.h
View File

@ -22,7 +22,7 @@
#include "CanSpamReceiver.h"
#include "CanSpamTransmitter.h"
#include "Lins.h"
#include "LinTasks.h"
#include "LinActuatorTasks.h"
#include "AdcTasks.h"
#include "standby.h"
#include "Model_Task.h"
@ -59,7 +59,9 @@ typedef struct {
tCanSpamReceiver canSpamReceiver;
tCanSpamTransmitter canSpamTransmitter;
tLinTaskActuator linTaskActuator0;
tLinTaskActuator linTaskActuator1;
tLinTaskActuator linTaskActuator2;
tLinTaskActuator linTaskActuator3;
tAdcTask adcTask0;
tAdcTask adcTask1;
@ -77,9 +79,14 @@ typedef struct {
osThreadAttr_t attr;
} thread;
// ExtU rtU_local;
// ExtY rtY_local;
DW rtDW;
// Входные данные (локальные) для модели
ActuatorCmdBus controllerData_local;
CmdBusADCData ADC_Data_Model_local;
// Входные данные (локальные) для модели
ActuatorCmdBusInput controllerDataInput_local;
uint8_t in_Busy_Ch0;
uint8_t in_Error_Connect_Ch0;
bool isActuatorWorkBusy;

16
MainModesArbiter_InitStage.c
View File

@ -132,9 +132,19 @@ static void Mma_InitSubSystems(tMma *env) {
CanSpamTransmitter_Init(&env->canSpamTransmitter, &env->canPorts->Can0_IO);
CanSpamTransmitter_StartThread(&env->canSpamTransmitter);
tLinData *linData = Lin1_Init(GetLin0CallbackHandler);
Lin_0_Init(&env->linTaskActuator0, linData, &env->linPorts->lin1_Io, &env->slog.logger);
Lin0_StartThread(&env->linTaskActuator0);
tLinData *linData1 = Lin1_Init(GetLin123CallbackHandler);
Lin_1_Init(&env->linTaskActuator1, linData1, &env->linPorts->lin1_Io, 9, &env->slog.logger);
Lin1_StartThread(&env->linTaskActuator1);
tLinData *linData2 = Lin2_Init(GetLin123CallbackHandler);
Lin_2_Init(&env->linTaskActuator2, linData2, &env->linPorts->lin2_Io, 6, &env->slog.logger);
Lin2_StartThread(&env->linTaskActuator2);
tLinData *linData3 = Lin3_Init(GetLin123CallbackHandler);
Lin_3_Init(&env->linTaskActuator3, linData3, &env->linPorts->lin3_Io, 8, &env->slog.logger);
Lin3_StartThread(&env->linTaskActuator3);
Adc_0_Init(&env->adcTask0, &env->adcs->adc_0_IO, env->gpios);
Adc_0_StartThread(&env->adcTask0);