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. // Created by cfif on 20.01.2026.
// //
#include "LinActuatorWork.h" #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]; linTaskActuator->linCommandActuator[i].POS = env->controllerData_local.POS[i];
env->linTaskActuator0.linCommandActuator[i].BUS_ADR = env->rtY_local.Out1.BUS_ADR[i]; linTaskActuator->linCommandActuator[i].BUS_ADR = env->controllerData_local.BUS_ADR[i];
env->linTaskActuator0.linCommandActuator[i].MODE = env->rtY_local.Out1.MODE[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) #if (LOG_LIN_ACTUATOR == 1)
LoggerInfoStatic(LOGGER, LOG_TASK_ARB, "SUCCESSFUL COMMAND") LoggerInfoStatic(LOGGER, LOG_SIGN, "SUCCESSFUL COMMAND")
#endif #endif
// Установка входной команды в LIN_ACT_CFR_NONE // Установка входной команды в 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]; linTaskActuator->linCommandActuator[i].COM = env->controllerData_local.COM[i];
env->linTaskActuator0.linCommandActuator[i].Stall_SET = env->rtY_local.Out1.Stall_SET[i]; linTaskActuator->linCommandActuator[i].Stall_SET = env->controllerData_local.Stall_SET[i];
env->linTaskActuator0.linCommandActuator[i].Lnoise_SET = env->rtY_local.Out1.Lnoise_SET[i]; linTaskActuator->linCommandActuator[i].Lnoise_SET = env->controllerData_local.Lnoise_SET[i];
env->linTaskActuator0.linCommandActuator[i].Autos_SET = env->rtY_local.Out1.Autos_SET[i]; linTaskActuator->linCommandActuator[i].Autos_SET = env->controllerData_local.Autos_SET[i];
env->linTaskActuator0.linCommandActuator[i].Speed_SET = env->rtY_local.Out1.Speed_SET[i]; linTaskActuator->linCommandActuator[i].Speed_SET = env->controllerData_local.Speed_SET[i];
env->linTaskActuator0.linCommandActuator[i].Coils_Stop_SET = env->rtY_local.Out1.Coils_Stop_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->controllerDataInput_local.in_CPOS_ALL_Ch0[i] = (int16_t) linTaskActuator->linStateActuator[i].CPOS_ALL;
env->rtU_local.in_Act_Emrf_Slave_Ch0[i] = (int8_t) env->linTaskActuator0.linStateActuator[i].Emrf_Slave; env->controllerDataInput_local.in_Act_Emrf_Slave_Ch0[i] = (int8_t) linTaskActuator->linStateActuator[i].Emrf_Slave;
env->rtU_local.in_Mode_Slave_Ch0[i] = (int8_t) env->linTaskActuator0.linStateActuator[i].Mode_Slave; env->controllerDataInput_local.in_Mode_Slave_Ch0[i] = (int8_t) linTaskActuator->linStateActuator[i].Mode_Slave;
env->rtU_local.in_Act_Err1_Supply_Ch0[i] = (int8_t) env->linTaskActuator0.linStateActuator[i].Error1_Supply_Slave; env->controllerDataInput_local.in_Act_Err1_Supply_Ch0[i] = (int8_t) linTaskActuator->linStateActuator[i].Error1_Supply_Slave;
env->rtU_local.in_Act_Err2_Communication_Ch0[i] = (int8_t) env->linTaskActuator0.linStateActuator[i].Error2_Communication_Slave; env->controllerDataInput_local.in_Act_Err2_Communication_Ch0[i] = (int8_t) linTaskActuator->linStateActuator[i].Error2_Communication_Slave;
env->rtU_local.in_Act_Err3_Temperature_Ch0[i] = (int8_t) env->linTaskActuator0.linStateActuator[i].Error3_Temperature_Slave; env->controllerDataInput_local.in_Act_Err3_Temperature_Ch0[i] = (int8_t) linTaskActuator->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->controllerDataInput_local.in_Act_Err4_Permanent_Electrical_Ch0[i] = (int8_t) linTaskActuator->linStateActuator[i].Error4_Permanent_Electrical_Slave;
env->rtU_local.in_Act_Stall_Slave_Ch0[i] = env->linTaskActuator0.linStateActuator[i].Stall_Slave; env->controllerDataInput_local.in_Act_Stall_Slave_Ch0[i] = linTaskActuator->linStateActuator[i].Stall_Slave;
env->rtU_local.in_Act_Reset_Ch0[i] = env->linTaskActuator0.linStateActuator[i].Reset_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->in_Error_Connect_Ch0 = linTaskActuator->error_connect;
env->rtU_local.in_Busy_Ch0 = env->linTaskActuator0.busy; 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 (env->ModelTask.triggerCommand == true) {
#if (LOG_LIN_ACTUATOR == 1) #if (LOG_LIN_ACTUATOR == 1)
LoggerInfoStatic(LOGGER, LOG_TASK_ARB, "DETECT COMMAND") LoggerInfoStatic(LOGGER, LOG_SIGN, "DETECT COMMAND")
#endif #endif
// //
env->rtU_local.in_Busy_Ch0 = 1; env->in_Busy_Ch0 = 1;
} }
// Если прията команда и актуатор не занят // Если прията команда и актуатор не занят
@ -71,23 +75,26 @@ void LinActuatorWork(tMma *env) {
env->isActuatorWorkBusy = true; env->isActuatorWorkBusy = true;
// Сброс STALL в состоянии актуатор и локальном состоянии // Сброс STALL в состоянии актуатор и локальном состоянии
resetStall(&env->linTaskActuator0, (uint8_t *) env->rtU_local.in_Act_Stall_Slave_Ch0); resetStall(linTaskActuator, (uint8_t *) env->controllerDataInput_local.in_Act_Stall_Slave_Ch0);
// Копирование команд
for (uint8_t i = 0; i < 9; ++i) {
rtY.Out1.COM[i] = env->ModelTask.numCommand[i];
}
// ВЫХОД МОДЕЛИ (АКТУАТОР) // ВЫХОД МОДЕЛИ (АКТУАТОР)
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); osMutexRelease(env->ModelTask.access);
} }
} }
*/

2
LinActuatorWork.h
View File

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

188
MainModesArbiter.c
View File

@ -5,6 +5,7 @@
#include "stdio.h" #include "stdio.h"
#include "fc7xxx_driver_rgm.h" #include "fc7xxx_driver_rgm.h"
#include "Model_actuator.h" #include "Model_actuator.h"
#include "LinActuatorWork.h"
#include "ADC_Temp_Table.h" #include "ADC_Temp_Table.h"
@ -112,14 +113,18 @@ void LoadDataInFromModel(tMma *env) {
if (env->adcTask0.ADC_isUpdate) { if (env->adcTask0.ADC_isUpdate) {
env->adcTask0.ADC_isUpdate = false; env->adcTask0.ADC_isUpdate = false;
/* memcpy(&env->ADC_Data_Model_local, &env->adcTask0.ADC0_Data, sizeof(env->adcTask0.ADC0_Data));
temp1 = get_temperature_fast(env->adcTask0.ADC0_Data.Sensor_Ambient_Temp); asm("nop");
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;
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 В) // 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; // 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) { if (env->adcTask1.ADC_isUpdate) {
env->adcTask1.ADC_isUpdate = false; 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 В) // 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; // 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) // 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) { 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(); 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) { if (env->ModelTask.isUpdate) {
env->ModelTask.isUpdate = false; env->ModelTask.isUpdate = false;
@ -222,10 +236,14 @@ void LoadDataInFromModel(tMma *env) {
osMutexRelease(env->ModelTask.access); osMutexRelease(env->ModelTask.access);
} }
} }
static _Noreturn void Mma_Thread(tMma *env) { static _Noreturn void Mma_Thread(tMma *env) {
uint8_t step = 0;
bool busy = false;
// Запуск устройства // Запуск устройства
Mma_InitStage(env); Mma_InitStage(env);
@ -266,12 +284,11 @@ static _Noreturn void Mma_Thread(tMma *env) {
env->pwms->pwmRearReservedIo.setActivePercent(env->pwms->pwmRearReservedIo.env, 50); env->pwms->pwmRearReservedIo.setActivePercent(env->pwms->pwmRearReservedIo.env, 50);
for (;;) { for (;;) {
/*
SystemDelayMs(10); SystemDelayMs(10);
uint8_t pwm1 = env->pwms->pwmFrontCaptureIO.getPwm(env->pwms->pwmFrontCaptureIO.env); uint8_t pwm1 = env->pwms->pwmFrontCaptureIO.getPwm(env->pwms->pwmFrontCaptureIO.env);
LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Front) = %d", pwm1) LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Front) = %d", pwm1)
SystemDelayMs(10); SystemDelayMs(10);
uint8_t pwm2 = env->pwms->pwmRearCaptureIO.getPwm(env->pwms->pwmRearCaptureIO.env); uint8_t pwm2 = env->pwms->pwmRearCaptureIO.getPwm(env->pwms->pwmRearCaptureIO.env);
LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Rear) = %d", pwm2) LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Rear) = %d", pwm2)
@ -279,19 +296,19 @@ static _Noreturn void Mma_Thread(tMma *env) {
SystemDelayMs(10); SystemDelayMs(10);
uint8_t pwm3 = env->pwms->pwmFrontCaptureIO.getPwm(env->pwms->pwmFrontReservedCaptureIO.env); uint8_t pwm3 = env->pwms->pwmFrontCaptureIO.getPwm(env->pwms->pwmFrontReservedCaptureIO.env);
LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Front Reserve) = %d", pwm3) LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Front Reserve) = %d", pwm3)
LoadDataInFromModel(env);
SystemDelayMs(10); SystemDelayMs(10);
uint8_t pwm4 = env->pwms->pwmRearCaptureIO.getPwm(env->pwms->pwmRearReservedCaptureIO.env); uint8_t pwm4 = env->pwms->pwmRearCaptureIO.getPwm(env->pwms->pwmRearReservedCaptureIO.env);
LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Rear Reserve) = %d", pwm4) LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "PWM (Rear Reserve) = %d", pwm4)
*/
LoadDataInFromModel(env); LoadDataInFromModel(env);
// LinActuatorWork(env, &env->linTaskActuator1);
SystemDelayMs(100);
SystemDelayMs(500);
GpioPinToggle(&env->gpios->led.LED_G); 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) || if (osMutexAcquire(linTaskActuator->access, 5000) == osOK) {
(env->linTaskActuator0.linCommandActuator[0].COM == LIN_ACT_CFR_NONE)) {
if ((linTaskActuator->linCommandActuator[0].COM == LIN_ACT_CFR_SUCCESSFUL) ||
(linTaskActuator->linCommandActuator[0].COM == LIN_ACT_CFR_NONE)) {
busy = true; busy = true;
} }
@ -330,49 +350,48 @@ static _Noreturn void Mma_Thread(tMma *env) {
switch (step) { switch (step) {
case 0: { case 0: {
resetStall(&env->linTaskActuator0); resetStall(linTaskActuator, local);
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_MOD; linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_MOD;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0; linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].MODE = LIN_MODE_STOP; linTaskActuator->linCommandActuator[0].MODE = LIN_MODE_STOP;
++step; ++step;
break; break;
} }
case 1: { case 1: {
resetStall(&env->linTaskActuator0); resetStall(linTaskActuator, local);
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_INI; linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_INI;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0; linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].POS = 6000; linTaskActuator->linCommandActuator[0].POS = 6000;
++step; ++step;
break; break;
} }
case 2: { case 2: {
resetStall(linTaskActuator, local);
resetStall(&env->linTaskActuator0); linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_MOD;
linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_MOD; linTaskActuator->linCommandActuator[0].MODE = LIN_MODE_NORMAL;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].MODE = LIN_MODE_NORMAL;
++step; ++step;
break; break;
} }
case 3: { case 3: {
resetStall(&env->linTaskActuator0); resetStall(linTaskActuator, local);
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_SET; linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_SET;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0; linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].POS = 0; linTaskActuator->linCommandActuator[0].POS = 0;
env->linTaskActuator0.linCommandActuator[0].Stall_SET = 1; linTaskActuator->linCommandActuator[0].Stall_SET = 1;
env->linTaskActuator0.linCommandActuator[0].Lnoise_SET = 0; linTaskActuator->linCommandActuator[0].Lnoise_SET = 0;
env->linTaskActuator0.linCommandActuator[0].Autos_SET = 1; linTaskActuator->linCommandActuator[0].Autos_SET = 1;
env->linTaskActuator0.linCommandActuator[0].Speed_SET = 3; linTaskActuator->linCommandActuator[0].Speed_SET = 3;
env->linTaskActuator0.linCommandActuator[0].Coils_Stop_SET = 0; linTaskActuator->linCommandActuator[0].Coils_Stop_SET = 0;
++step; ++step;
@ -380,10 +399,29 @@ static _Noreturn void Mma_Thread(tMma *env) {
} }
case 4: { 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"); asm("nop");
++step; ++step;
//if (env->linTaskActuator0.linStateActuator[7].CPOS_ALL == 0) { //if (linTaskActuator->linStateActuator[7].CPOS_ALL == 0) {
// ++step; // ++step;
//} //}
break; break;
@ -391,11 +429,11 @@ static _Noreturn void Mma_Thread(tMma *env) {
case 5: { case 5: {
resetStall(&env->linTaskActuator0); resetStall(linTaskActuator, local);
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_INI; linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_INI;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0; linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].POS = 0; linTaskActuator->linCommandActuator[0].POS = 0;
++step; ++step;
break; break;
@ -403,16 +441,16 @@ static _Noreturn void Mma_Thread(tMma *env) {
case 6: { case 6: {
resetStall(&env->linTaskActuator0); resetStall(linTaskActuator, local);
env->linTaskActuator0.linCommandActuator[0].COM = LIN_ACT_CFR_SET; linTaskActuator->linCommandActuator[0].COM = LIN_ACT_CFR_SET;
env->linTaskActuator0.linCommandActuator[0].BUS_ADR = 0; linTaskActuator->linCommandActuator[0].BUS_ADR = 0;
env->linTaskActuator0.linCommandActuator[0].POS = 6000; linTaskActuator->linCommandActuator[0].POS = 6000;
env->linTaskActuator0.linCommandActuator[0].Stall_SET = 1; linTaskActuator->linCommandActuator[0].Stall_SET = 1;
env->linTaskActuator0.linCommandActuator[0].Lnoise_SET = 0; linTaskActuator->linCommandActuator[0].Lnoise_SET = 0;
env->linTaskActuator0.linCommandActuator[0].Autos_SET = 1; linTaskActuator->linCommandActuator[0].Autos_SET = 1;
env->linTaskActuator0.linCommandActuator[0].Speed_SET = 3; linTaskActuator->linCommandActuator[0].Speed_SET = 3;
env->linTaskActuator0.linCommandActuator[0].Coils_Stop_SET = 0; linTaskActuator->linCommandActuator[0].Coils_Stop_SET = 0;
++step; ++step;
@ -420,20 +458,54 @@ static _Noreturn void Mma_Thread(tMma *env) {
} }
case 7: { 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"); asm("nop");
++step; ++step;
//if (env->linTaskActuator0.linStateActuator[7].CPOS_ALL >= 6000) { //if (linTaskActuator->linStateActuator[7].CPOS_ALL >= 6000) {
// ++step; // ++step;
//} //}
break; break;
} }
case 8: { case 8: {
if (env->linTaskActuator0.linStateActuator[7].CPOS_ALL >= 8000) { if (linTaskActuator->linStateActuator[7].CPOS_ALL >= 8000) {
++step; ++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; 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) LoggerFormatInfo(LOGGER, LOG_TASK_ARB, "Step = %d", step)
*/
*/

17
MainModesArbiter.h
View File

@ -22,7 +22,7 @@
#include "CanSpamReceiver.h" #include "CanSpamReceiver.h"
#include "CanSpamTransmitter.h" #include "CanSpamTransmitter.h"
#include "Lins.h" #include "Lins.h"
#include "LinTasks.h" #include "LinActuatorTasks.h"
#include "AdcTasks.h" #include "AdcTasks.h"
#include "standby.h" #include "standby.h"
#include "Model_Task.h" #include "Model_Task.h"
@ -59,7 +59,9 @@ typedef struct {
tCanSpamReceiver canSpamReceiver; tCanSpamReceiver canSpamReceiver;
tCanSpamTransmitter canSpamTransmitter; tCanSpamTransmitter canSpamTransmitter;
tLinTaskActuator linTaskActuator0; tLinTaskActuator linTaskActuator1;
tLinTaskActuator linTaskActuator2;
tLinTaskActuator linTaskActuator3;
tAdcTask adcTask0; tAdcTask adcTask0;
tAdcTask adcTask1; tAdcTask adcTask1;
@ -77,9 +79,14 @@ typedef struct {
osThreadAttr_t attr; osThreadAttr_t attr;
} thread; } thread;
// ExtU rtU_local; // Входные данные (локальные) для модели
// ExtY rtY_local; ActuatorCmdBus controllerData_local;
DW rtDW; CmdBusADCData ADC_Data_Model_local;
// Входные данные (локальные) для модели
ActuatorCmdBusInput controllerDataInput_local;
uint8_t in_Busy_Ch0;
uint8_t in_Error_Connect_Ch0;
bool isActuatorWorkBusy; 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_Init(&env->canSpamTransmitter, &env->canPorts->Can0_IO);
CanSpamTransmitter_StartThread(&env->canSpamTransmitter); CanSpamTransmitter_StartThread(&env->canSpamTransmitter);
tLinData *linData = Lin1_Init(GetLin0CallbackHandler);
Lin_0_Init(&env->linTaskActuator0, linData, &env->linPorts->lin1_Io, &env->slog.logger); tLinData *linData1 = Lin1_Init(GetLin123CallbackHandler);
Lin0_StartThread(&env->linTaskActuator0); 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_Init(&env->adcTask0, &env->adcs->adc_0_IO, env->gpios);
Adc_0_StartThread(&env->adcTask0); Adc_0_StartThread(&env->adcTask0);