1634 lines
70 KiB
C
1634 lines
70 KiB
C
|
||
// flash sector
|
||
|
||
// uint8_t packet[] = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
|
||
// env->signature.atCmd = &env->gsmWithGnss.gsmAt;
|
||
// env->signature.slog = &env->slog;
|
||
//// while (1){
|
||
// EraTSK_GetPackSignature(&env->signature,packet,sizeof(packet));
|
||
// SystemDelayMs(10);
|
||
// // SystemDelayMs(1);
|
||
//// }
|
||
// return;
|
||
|
||
|
||
//
|
||
// Created by xemon on 19.09.22.
|
||
//
|
||
//+79419776358
|
||
// +79418100029
|
||
|
||
#include "MainModesArbiter_Private.h"
|
||
#include "BootJump.h"
|
||
#include "DeviceTesting_TestsWithUser.h"
|
||
#include "AtGsmOpenAudioLoop.h"
|
||
#include "egts.h"
|
||
#include "AsciiStringAssmeblingUtils.h"
|
||
#include "AtGsmSms_DeleteAll.h"
|
||
#include "DeviceTesting.h"
|
||
#include "stream.h"
|
||
//#include "PointEvent.h"
|
||
#include "DeviceTesting_TestingMethods.h"
|
||
#include "Accel.h"
|
||
#define LOG_SIGN "Главн."
|
||
#define LOGGER &env->slog.logger
|
||
|
||
size_t str_len = 0;
|
||
char step[5] = {0};
|
||
|
||
void Mma_Init(
|
||
tMma *env,
|
||
tGpios *gpios,
|
||
tSerialPorts *serialPorts,
|
||
tI2cPorts *i2cPorts,
|
||
tSpiPorts *spiPorts,
|
||
tAdcs *adcs,
|
||
tStorageOnFlash *flash,
|
||
tRtcs *rtc,
|
||
tCanPorts *canPorts
|
||
) {
|
||
env->accel = &ACCEL;
|
||
env->gpios = gpios;
|
||
env->serialPorts = serialPorts;
|
||
env->i2cPorts = i2cPorts;
|
||
env->spiPorts = spiPorts;
|
||
env->canPorts = canPorts;
|
||
env->adcs = adcs;
|
||
env->flash = flash;
|
||
env->rtc = rtc;
|
||
InitThreadAtrStatic(&env->thread.attr, "Mma", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
|
||
env->thread.id = 0;
|
||
env->lastSmsCheckTime = SystemGetMs() + 8000;
|
||
env->flIgn = false;
|
||
env->userInputSubstart = 0;
|
||
env->mux_factoryMode = osMutexNew(NULL);
|
||
env->tmt = SystemGetMs() + 5000;
|
||
env->tm_FactoryMessage = SystemGetMs() + 5000;
|
||
env->fl_iniSysIsDone = false;
|
||
env->checNetDeGeg = false;
|
||
env->eolAcsess = false;
|
||
env->fl_isFacrotyMode = false;
|
||
env->telematicaIsConnect = TELE_ACSESS_TEMPORARY;
|
||
}
|
||
|
||
/*
|
||
void Mma_SetAccessProtection(){
|
||
flash_status_type status = FLASH_OPERATE_DONE;
|
||
if(flash_fap_status_get() == RESET) {
|
||
flash_unlock();
|
||
status = flash_operation_wait_for(OPERATION_TIMEOUT);
|
||
if (status != FLASH_OPERATE_TIMEOUT) {
|
||
if ((status == FLASH_PROGRAM_ERROR) || (status == FLASH_EPP_ERROR))
|
||
flash_flag_clear(FLASH_PRGMERR_FLAG | FLASH_EPPERR_FLAG);
|
||
status = flash_fap_enable(TRUE);
|
||
if (status == FLASH_OPERATE_DONE){
|
||
//nvic_system_reset();
|
||
}
|
||
flash_lock();
|
||
}
|
||
flash_lock();
|
||
}
|
||
}
|
||
*/
|
||
|
||
|
||
static _Noreturn void Mma_AccompanModeThread(tMma *env) {
|
||
while (1) {
|
||
Mma_AccompanMode(env);
|
||
SystemDelayMs(40);
|
||
}
|
||
}
|
||
|
||
|
||
void AccompanModeStartThread(tMma *env) {
|
||
if (!env->threadAccompanMode.id) {
|
||
env->threadAccompanMode.id = osThreadNew(
|
||
(osThreadFunc_t) (Mma_AccompanModeThread),
|
||
(void *) (env),
|
||
&env->threadAccompanMode.attr
|
||
);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Сопроводительный поток запущен")
|
||
}
|
||
}
|
||
|
||
void AccompanModeStopThread(tMma *env) {
|
||
if (env->threadAccompanMode.id != NULL) {
|
||
if (osThreadTerminate(env->threadAccompanMode.id) == osOK) {
|
||
SystemDelayMs(100);
|
||
env->threadAccompanMode.id = NULL;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Сопроводительный поток остановлен")
|
||
SystemDelayMs(500);
|
||
}
|
||
}
|
||
}
|
||
|
||
// не трогать дэлэи !!!
|
||
void Mma_AudioSubSystemStart(tPowerManagement *power, tAmplifier *amplifier) {
|
||
Pwm_SetMuteInCar(power, true);
|
||
SystemDelayMs(100);
|
||
Mma_AudioTestSetMode(power, false);
|
||
SystemDelayMs(200);
|
||
Pwm_AmpOn(power);
|
||
SystemDelayMs(800);
|
||
Amplifier_StartUp(amplifier);
|
||
SystemDelayMs(1600);
|
||
}
|
||
/*
|
||
void Mma_ShortShutdown(tMma *env) {
|
||
if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) {
|
||
EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_SHUTDOWN);
|
||
}
|
||
|
||
Pwm_GsmAndGnssShutDown(&env->power);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Завершение работы")
|
||
VarsTabDumpObserver_Flush(&env->storage.dumpObserver);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение питания через 4 с")
|
||
SystemDelayMs(4000);
|
||
Pwm_Blackout(&env->power);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Питание осталось, обратите внимание!!")
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Возможно произошло повторное включение пользователем")
|
||
env->eolAcsess = false;
|
||
SystemDelayMs(500);
|
||
|
||
nvic_system_reset();
|
||
//BootJumpToAddress(0x8000000);
|
||
LoggerErrorStatic(LOGGER, LOG_SIGN, "Этой строчки не должно быть! Критическая ошибка!")
|
||
}
|
||
*/
|
||
|
||
void Mma_Shutdown(tMma *env) {
|
||
if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) {
|
||
EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_SHUTDOWN);
|
||
}
|
||
|
||
Pwm_GsmAndGnssShutDown(&env->power);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Завершение работы")
|
||
VarsTabDumpObserver_Flush(&env->storage.dumpObserver);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение питания через 4 с")
|
||
SystemDelayMs(4000);
|
||
Pwm_Blackout(&env->power);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Питание осталось, обратите внимание!!")
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Возможно произошло повторное включение пользователем")
|
||
env->eolAcsess = false;
|
||
SystemDelayMs(500);
|
||
|
||
nvic_system_reset();
|
||
//BootJumpToAddress(0x8000000);
|
||
LoggerErrorStatic(LOGGER, LOG_SIGN, "Этой строчки не должно быть! Критическая ошибка!")
|
||
}
|
||
|
||
void Mma_CheckShutdownIsBattary(tMma *env) {
|
||
bool statShutdown = Pwm_IsShutdownRequired(&env->power);
|
||
if ((env->indication.mode != DEVICE_MODE_TESTING) && (env->indication.mode != DEVICE_MODE_UVEOS_GARAG)) {
|
||
if (statShutdown) {
|
||
uint16_t single;
|
||
float volt;
|
||
single = env->power.powerSusystem->battery.currentBatVoltage;
|
||
volt = (float) single / 1000;
|
||
if (volt < 2.0) {
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "===================================================")
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "ОТКЛЮЧЕНИЕ УСТРОЙСТВА ПО ДОСТИЖЕНИЮ КРИТИЧЕСКИ НИЗКОГО")
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, " УРОВНЯ ЗАРЯДА РЕЗЕРВНОГО ИСТОЧНИКА ПИТАНИЯ")
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "===================================================")
|
||
Mma_Shutdown(env);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void Mma_AudioTestSetMode(tPowerManagement *env, bool fl) {
|
||
env->powerSusystem->SpekTestPower.speakTestAcsess = fl;
|
||
}
|
||
|
||
void Mma_CheckShutdown(tMma *env) {
|
||
if (env->fl_iniSysIsDone == false) {
|
||
return;
|
||
}
|
||
|
||
bool statIgnition = Pwm_IsShutdownRequired(&env->power); // ignition
|
||
bool statIsNetwork = EraGlonassUveos_IsStandby(&env->uveos); // timings.requireNetwork
|
||
bool statStandFulPower = EraGlonassUveos_IsAllowInCall(&env->uveos); // timings.allowInCall
|
||
bool statTestTimer = EraGlonassUveos_IsStandbyTestTimer(&env->uveos);
|
||
|
||
if ((statIsNetwork && statTestTimer) && (statStandFulPower) && (!statIgnition)) {
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
}
|
||
|
||
if ((statIgnition) && (!statIsNetwork) && (!statStandFulPower)) {
|
||
Mma_Shutdown(env);
|
||
}
|
||
|
||
Mma_CheckShutdownIsBattary(env);
|
||
}
|
||
|
||
void Mma_SetNetworkRegistration(tMma *env, bool value) {
|
||
if (value == true) {
|
||
if (env->gsmWithGnss.isRegToGSM == false) {
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Инициализирована автоматическая регистрация из сети наземной связи")
|
||
if (GsmWithGnss_NetworkSetStateInnaterups(&env->gsmWithGnss, 4, 4000) == AT_ERROR) {
|
||
env->tmpTm = SystemGetMs() + 10000;
|
||
while (
|
||
(GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 1500) == false) &&
|
||
(env->tmpTm > SystemGetMs())
|
||
) {
|
||
SystemDelayMs(1000);
|
||
}
|
||
} else {
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Регистрация в сети присутствует, код 4")
|
||
}
|
||
}
|
||
} else {
|
||
if (env->gsmWithGnss.isRegToGSM == true) {
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Инициализирована автоматическая деригистрация из сети наземной связи")
|
||
if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) {
|
||
AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt);
|
||
SystemDelayMs(1000);
|
||
AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt);
|
||
osMutexRelease(env->gsmWithGnss.gsmAt.access);
|
||
}
|
||
if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 1500) == true) {
|
||
env->tmpTm = SystemGetMs() + 10000;
|
||
while (
|
||
(GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 1500) == true) &&
|
||
(env->tmpTm > SystemGetMs())
|
||
) {
|
||
SystemDelayMs(1000);
|
||
}
|
||
} else {
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Деригистрация в сети выполнена, код 4")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void Mma_CanProcRunTests(tMma *env) {
|
||
tDeviceModes indicationState = env->indication.mode;
|
||
|
||
// eSubSystems eSubSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector);
|
||
if (env->queryUDSState.source != SPEAK_MICR_TEST) {
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
}
|
||
|
||
Mma_RunUserTests(env, true);
|
||
|
||
env->indication.mode = indicationState;
|
||
Mma_SetMode(env, indicationState);
|
||
}
|
||
|
||
tDeviceModes *UserIndication_GetMode(tMma *env) {
|
||
return &env->indication.mode;
|
||
}
|
||
|
||
void Mma_GarageMode(tMma *env) {
|
||
AccompanModeStopThread(env);
|
||
Mma_AudioSubSystemStart(&env->power, &env->amplifier);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим Гараж")
|
||
GpioPinEnable(&env->power.powerSusystem->main.garage);
|
||
|
||
SystemDelayMs(40);
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "servise_mode.mp3", 4 * 1000);
|
||
Mma_AudioSubSystemRelease(env);
|
||
|
||
env->storage.nvm->device.serviseMode = true;
|
||
DeviceStorage_ForceDump(&env->storage);
|
||
|
||
EraGlonassUveos_GarageStarted(&env->uveos);
|
||
tUserInputButtonEvent buttonEvent = {0};
|
||
while (1) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим Гараж")
|
||
|
||
if (DeviceTesting_Periodical(&env->testing)) {
|
||
Mma_SetMode(env, DEVICE_MODE_FAILURE);
|
||
} else {
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_GARAG);
|
||
}
|
||
|
||
if (env->storage.runtime.enableGnssUpdate) {
|
||
EraGlonassUveos_DoNothingModeDistance(&env->uveos, true);
|
||
}
|
||
|
||
if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_DISABLED) {
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_UNDEFINDET);
|
||
AccompanModeStartThread(env);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Автоматический выход из режима Гараж")
|
||
GpioPinDisable(&env->power.powerSusystem->main.garage);
|
||
env->storage.nvm->device.serviseMode = false;
|
||
DeviceStorage_ForceDump(&env->storage);
|
||
EraGlonassUveos_DoNotingReset(&env->uveos);
|
||
|
||
Mma_AudioSubSystemRequire(env);
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "era_mode.mp3", 4 * 1000);
|
||
Mma_AudioSubSystemRelease(env);
|
||
|
||
uint32_t tm = SystemGetMs() + 1000;
|
||
while (tm < SystemGetMs()) {}
|
||
return;
|
||
}
|
||
|
||
if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
|
||
if (UserInputButtonEventIsBetween(buttonEvent, UI_VIRT_BUTTON_ADDITIONAL, RAISE, SERVICE_MODE_MIN, SERVICE_MODE_MAX)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Пользовательский выход из режима Гараж")
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_UNDEFINDET);
|
||
AccompanModeStartThread(env);
|
||
GpioPinDisable(&env->power.powerSusystem->main.garage);
|
||
env->storage.nvm->device.serviseMode = false;
|
||
DeviceStorage_ForceDump(&env->storage);
|
||
EraGlonassUveos_DoNotingReset(&env->uveos);
|
||
|
||
Mma_AudioSubSystemRequire(env);
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "era_mode.mp3", 4 * 1000);
|
||
|
||
uint32_t tm = SystemGetMs() + 1000;
|
||
while (tm < SystemGetMs()) {}
|
||
|
||
Mma_AudioSubSystemRelease(env);
|
||
return;
|
||
}
|
||
}
|
||
|
||
|
||
Mma_CheckShutdown(env);
|
||
SystemDelayMs(500);
|
||
}
|
||
}
|
||
|
||
void Mma_SubstartTelematica(tMma *env) {
|
||
env->uveos.doNothing.mode = UVEOS_DO_NOTHING_DISABLED;
|
||
bool statIgnition = Pwm_IsShutdownRequired(&env->power); // ignition
|
||
bool statIsNetwork = EraGlonassUveos_IsStandby(&env->uveos); // timings.requireNetwork
|
||
bool statStandFulPower = EraGlonassUveos_IsAllowInCall(&env->uveos); // timings.allowInCall
|
||
bool statTestTimer = EraGlonassUveos_IsStandbyTestTimer(&env->uveos);
|
||
|
||
if (env->fl_iniSysIsDone == true) {
|
||
if ((!statIsNetwork && !statTestTimer) && (!statStandFulPower) && (!statIgnition)) {
|
||
if ((env->telematicaIsConnect == TELE_ACSESS_LOCAL) || (env->telematicaIsConnect == TELE_ACSESS_SERVER)) {
|
||
SystemSelector(&env->systemSwitcher, TELEMATICA);
|
||
}
|
||
|
||
if (env->telematicaIsConnect == TELE_ACSESS_TEMPORARY) {
|
||
SystemSelector(&env->systemSwitcher, TELEMATICA);
|
||
}
|
||
|
||
if (env->storage.nvm->device.telematicaIsActive) {
|
||
env->telematicaIsConnect = TELE_ACSESS_LOCAL;
|
||
}
|
||
|
||
if (env->storage.runtime.telematicaServerIsActive) {
|
||
env->telematicaIsConnect = TELE_ACSESS_SERVER;
|
||
}
|
||
|
||
if (env->telematicaIsConnect == TELE_ACSESS_DENATED) {
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
}
|
||
} else {
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
}
|
||
|
||
if (
|
||
(env->storage.runtime.telematicaWaitConnect == true) &&
|
||
(env->storage.nvm->device.telematicaIsActive == false) &&
|
||
(env->storage.runtime.telematicaServerIsActive == false)
|
||
) {
|
||
env->telematicaIsConnect = TELE_ACSESS_DENATED;
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
bool flSubSys = false;
|
||
bool flCrashDetectionStat = false;
|
||
uint32_t tmt = 0;
|
||
|
||
void Mma_AccompanMode(tMma *env) {
|
||
|
||
if (env->eolAcsess == true) {
|
||
Mma_ClearParams(env);
|
||
DeviceStorage_ForceDump(&env->storage);
|
||
Mma_Shutdown(env);
|
||
}
|
||
|
||
if ((env->threadSubstartChekButton.id == NULL) && (flSubSys == false)) {
|
||
Mma_UserInputSubstartButtonThreadStart(env);
|
||
flSubSys = true;
|
||
}
|
||
|
||
if (!env->storage.nvm->device.factoryMode) {
|
||
|
||
if ((*env->comInt.Amplifier.playMode == true)&&(env->ModemDataCollector.fl_IsLoad == true)) {
|
||
Mma_AudioSubSystemRequire(env);
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000);
|
||
*env->comInt.Amplifier.playMode = false;
|
||
Mma_AudioSubSystemRelease(env);
|
||
}
|
||
|
||
if (env->comInt.TestButton.run == true) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование из сервисного ПО")
|
||
env->testing.audioHintsMode = HINTS_NORMAL;
|
||
Mma_RunShortTest(env, true);
|
||
env->testing.audioHintsMode = HINTS_FULL;
|
||
env->comInt.TestButton.run = false;
|
||
}
|
||
|
||
if (env->crashDetect.carCrashDetection.isStarted == false) {
|
||
if (Mma_StartCrachDetectSubsystem(env) == true) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Подсистема Crash Detect запущена, запуск инициализирован из сопроводительно потока")
|
||
} else {
|
||
if(tmt < SystemGetMs()) {
|
||
tmt = SystemGetMs()+10000;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Опорные данные для работы акселерометра не установлены, повторная попытка запуска Crash Detect")
|
||
}
|
||
}
|
||
} else {
|
||
if (flCrashDetectionStat == false) {
|
||
flCrashDetectionStat = true;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Запуск Crash Detect не требуется, подсистема уже запущена")
|
||
}
|
||
}
|
||
|
||
tDeviceModes *deviceModes = UserIndication_GetMode(env);
|
||
if (DeviceTesting_Always(&env->testing)) {
|
||
if ((*deviceModes != DEVICE_MODE_TESTING) &&
|
||
(*deviceModes != DEVICE_MODE_UVEOS_PASSIVE)
|
||
) {
|
||
*deviceModes = DEVICE_MODE_FAILURE;
|
||
}
|
||
} else {
|
||
if (env->fl_iniSysIsDone == true) {
|
||
if ((*deviceModes != DEVICE_MODE_TESTING) &&
|
||
(*deviceModes != DEVICE_MODE_UVEOS_PASSIVE)&&
|
||
(*deviceModes != DEVICE_MODE_UVEOS_GARAG)
|
||
){
|
||
*deviceModes = DEVICE_MODE_UVEOS_UNDEFINDET;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (*deviceModes != DEVICE_MODE_FAILURE) {
|
||
if (DeviceTesting_Periodical(&env->testing)) {
|
||
if ((*deviceModes != DEVICE_MODE_TESTING) && (*deviceModes != DEVICE_MODE_UVEOS_PASSIVE)) {
|
||
*deviceModes = DEVICE_MODE_FAILURE;
|
||
}
|
||
} else {
|
||
if ((*deviceModes != DEVICE_MODE_TESTING) &&
|
||
(*deviceModes != DEVICE_MODE_UVEOS_PASSIVE)&&
|
||
(*deviceModes != DEVICE_MODE_UVEOS_GARAG)
|
||
) {
|
||
*deviceModes = DEVICE_MODE_UVEOS_UNDEFINDET;
|
||
}
|
||
}
|
||
}
|
||
|
||
if ((env->fl_iniSysIsDone) &&
|
||
(*deviceModes != DEVICE_MODE_TESTING) &&
|
||
(*deviceModes != DEVICE_MODE_UVEOS_PASSIVE) &&
|
||
(*deviceModes != DEVICE_MODE_UVEOS_GARAG)
|
||
)
|
||
{
|
||
Mma_SetMode(env, *deviceModes);
|
||
Mma_gnssUpdateIndication(env);
|
||
}
|
||
SystemDelayMs(500);
|
||
return;
|
||
}
|
||
|
||
///=============================================================================================
|
||
// раскерпичиватель модема
|
||
if (env->storage.nvm->device.factoryMode) {
|
||
if (DeviceTestsTable_MakeTest(env->testing.namedTests.vin) == DEVICE_TESTING_CODE_PASSED) {
|
||
env->storage.nvm->device.factoryMode = false;
|
||
EraGlonassUveosDumper_ForceDump(env->uveos.dumper);
|
||
uint32_t tmtt = SystemGetMs() + 4000;
|
||
while (tmtt > SystemGetMs()) {
|
||
SystemDelayMs(40);
|
||
}
|
||
}
|
||
}
|
||
|
||
env->playMode = true;
|
||
if (
|
||
(env->storage.nvm->device.factoryMode) &&
|
||
(osMutexAcquire(env->mux_factoryMode, 5000))
|
||
) {
|
||
|
||
tDeviceModes *deviceModes;
|
||
DeviceTesting_SetTelematicaTestMode(&env->testing, true);
|
||
Mma_UserInputSubstartButtonThreadStop(env);
|
||
|
||
|
||
#ifdef FIRMWARE_TEST
|
||
if ((env->playMode == true) && (env->ModemDataCollector.fl_IsLoad == true)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим производственного контроля")
|
||
env->playMode = false;
|
||
}
|
||
#else
|
||
if ((env->playMode == true) && (env->ModemDataCollector.fl_IsLoad == true)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим производственного контроля")
|
||
SystemDelayMs(1000);
|
||
Mma_AudioSubSystemRequire(env);
|
||
SystemDelayMs(1000);
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000);
|
||
env->playMode = false;
|
||
Mma_AudioSubSystemRelease(env);
|
||
}
|
||
#endif
|
||
|
||
bool fl_triger = true;
|
||
while (1) {
|
||
SystemSelector(&env->systemSwitcher, TELEMATICA);
|
||
if (env->tm_FactoryMessage < SystemGetMs()) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим производственного контроля")
|
||
env->tm_FactoryMessage = SystemGetMs() + 15000;
|
||
}
|
||
|
||
deviceModes = UserIndication_GetMode(env);
|
||
|
||
if (!env->storage.nvm->device.factoryMode) {
|
||
osMutexRelease(env->mux_factoryMode);
|
||
return;
|
||
}
|
||
|
||
#ifdef FIRMWARE_TEST
|
||
if ((env->playMode == true) && (env->ModemDataCollector.fl_IsLoad == true)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим производственного контроля")
|
||
env->playMode = false;
|
||
}
|
||
|
||
#else
|
||
if ((env->playMode == true) && (env->ModemDataCollector.fl_IsLoad == true)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим производственного контроля")
|
||
SystemDelayMs(1000);
|
||
Mma_AudioSubSystemRequire(env);
|
||
SystemDelayMs(1000);
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000);
|
||
env->playMode = false;
|
||
Mma_AudioSubSystemRelease(env);
|
||
}
|
||
#endif
|
||
if ((*env->comInt.Amplifier.playMode == true)&&(env->ModemDataCollector.fl_IsLoad == true)) {
|
||
Mma_AudioSubSystemRequire(env);
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000);
|
||
*env->comInt.Amplifier.playMode = false;
|
||
Mma_AudioSubSystemRelease(env);
|
||
}
|
||
|
||
if (env->comInt.TestButton.run == true) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование из сервисного ПО")
|
||
env->testing.audioHintsMode = HINTS_NORMAL;
|
||
Mma_RunShortTest(env, true);
|
||
env->testing.audioHintsMode = HINTS_FULL;
|
||
env->comInt.TestButton.run = false;
|
||
}
|
||
|
||
if (fl_triger == true) {
|
||
SystemSelector(&env->systemSwitcher, TELEMATICA);
|
||
fl_triger = false;
|
||
}
|
||
|
||
if (DeviceTesting_Always(&env->testing)) {
|
||
if (*deviceModes != DEVICE_MODE_TESTING) {
|
||
*deviceModes = DEVICE_MODE_FAILURE;
|
||
}
|
||
} else {
|
||
if (env->fl_iniSysIsDone == true) {
|
||
if (*deviceModes != DEVICE_MODE_TESTING) {
|
||
*deviceModes = DEVICE_MODE_UVEOS_UNDEFINDET;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (*deviceModes != DEVICE_MODE_FAILURE) {
|
||
if (DeviceTesting_Periodical(&env->testing)) {
|
||
if (*deviceModes != DEVICE_MODE_TESTING) {
|
||
*deviceModes = DEVICE_MODE_FAILURE;
|
||
}
|
||
} else {
|
||
if (*deviceModes != DEVICE_MODE_TESTING) {
|
||
*deviceModes = DEVICE_MODE_UVEOS_UNDEFINDET;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (
|
||
(env->fl_iniSysIsDone) &&
|
||
(*deviceModes != DEVICE_MODE_TESTING) &&
|
||
(*deviceModes != DEVICE_MODE_UVEOS_GARAG)
|
||
) {
|
||
|
||
Mma_SetMode(env, *deviceModes);
|
||
Mma_gnssUpdateIndication(env);
|
||
}
|
||
|
||
if (!env->storage.nvm->device.factoryMode) {
|
||
DeviceTestsTable_MakeTest(env->testing.namedTests.modemSimEra);
|
||
DeviceTestsTable_MakeTest(env->testing.namedTests.modemSimComers);
|
||
DeviceTestsTable_MakeTest(env->testing.namedTests.modemSoftRevision);
|
||
|
||
DeviceTesting_SetTelematicaTestMode(&env->testing, false);
|
||
SystemDelayMs(1000);
|
||
Mma_AudioSubSystemRequire(env);
|
||
SystemDelayMs(1000);
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "era_mode.mp3", 4 * 1000);
|
||
Mma_AudioSubSystemRelease(env);
|
||
|
||
if ((env->userInputSubstart == 1) || (env->userInputSubstart == 2)) {
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
ModemDataCollector_SelectionSimChip(&env->systemSelector, CHIP_ERA);
|
||
} else {
|
||
SystemSelector(&env->systemSwitcher, TELEMATICA);
|
||
}
|
||
|
||
if (env->threadSubstartChekButton.id == NULL) {
|
||
Mma_UserInputSubstartButtonThreadStart(env);
|
||
}
|
||
|
||
osMutexRelease(env->mux_factoryMode);
|
||
env->fl_isFacrotyMode = true;
|
||
EraGlonassUveosDumper_ForceDump(&env->storage.uveosDumper);
|
||
SystemDelayMs(100);
|
||
return;
|
||
}
|
||
|
||
Mma_RunTests(env);
|
||
|
||
#ifdef FIRMWARE_TEST
|
||
if ((*env->comInt.Amplifier.playMode == true)&&(env->ModemDataCollector.fl_IsLoad == true)) {
|
||
*env->comInt.Amplifier.playMode = false;
|
||
}
|
||
#else
|
||
if ((*env->comInt.Amplifier.playMode == true)&&(env->ModemDataCollector.fl_IsLoad == true)) {
|
||
Mma_AudioSubSystemRequire(env);
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000);
|
||
*env->comInt.Amplifier.playMode = false;
|
||
Mma_AudioSubSystemRelease(env);
|
||
}
|
||
#endif
|
||
if (env->comInt.TestButton.run == true) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование из сервисного ПО")
|
||
env->testing.audioHintsMode = HINTS_NORMAL;
|
||
Mma_RunShortTest(env, true);
|
||
env->testing.audioHintsMode = HINTS_FULL;
|
||
env->comInt.TestButton.run = false;
|
||
}
|
||
|
||
Mma_CheckShutdown(env);
|
||
SystemDelayMs(100);
|
||
}
|
||
}
|
||
}
|
||
|
||
void Mma_RunTests(tMma *env) {
|
||
if (env->testing.queryUDSState->commands == COM_RUN) {
|
||
Mma_CanProcRunTests(env);
|
||
if (env->storage.nvm->device.factoryMode == true) {
|
||
SystemSelector(&env->systemSwitcher, TELEMATICA);
|
||
}
|
||
}
|
||
}
|
||
|
||
void Mma_AudioSubSystemRelease(tMma *env) {
|
||
if (!env->storage.nvm->gost.notGost.ECALL_DEBUG_MODE) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализировано освобождение аудио подсистемы")
|
||
Pwm_SetMuteInCar(&env->power, false);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Сигнал MUTE снят с борт. сети")
|
||
Pwm_AmpOff(&env->power);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение УНЧ выполнено")
|
||
SystemDelayMs(200);
|
||
Mma_AudioTestSetMode(&env->power, true);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Тест наличия громкоговорителя включен код 2")
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "СИСТЕМА В РЕЖИМЕ ОТЛАДКИ, ОТКЛЮЧЕНИЕ АУДИО ПОДСИСТЕМЫ НЕ ВОЗМОЖЕН")
|
||
}
|
||
}
|
||
|
||
void Mma_AudioSubSystemRequire(tMma *env) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Включение аудио тракта")
|
||
Mma_AudioSubSystemStart(&env->power, &env->amplifier);
|
||
}
|
||
|
||
void Mma_NetworkRequire(tMma *env) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Проверка регистрацию в сети")
|
||
if (!GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 1500)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует, попытка регистрации код 2")
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_WAIT_NETWORK);
|
||
if (GsmWithGnss_NetworkSetStateInnaterups(&env->gsmWithGnss, 4, 20000) == AT_OK) {
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть присутствует")
|
||
return;
|
||
} else {
|
||
LoggerErrorStatic(LOGGER, LOG_SIGN, "нет сети")
|
||
}
|
||
} else {
|
||
LoggerErrorStatic(LOGGER, LOG_SIGN, "Регистрация в сети присутствует")
|
||
}
|
||
}
|
||
|
||
void Mma_gnssUpdateIndicationGetGnssState(tMma *env) {
|
||
if ((env->storage.runtime.enableGnssUpdate == true) && (env->indication.mode != DEVICE_MODE_TESTING) &&
|
||
(env->indication.mode != DEVICE_MODE_UVEOS_GARAG)) {
|
||
if (env->gsmWithGnss.gnss.currentRmc.status == 'A') {
|
||
if (ModemDataCollector_GetThisSubSystem(&env->systemSelector) == UVEOS) {
|
||
EraGlonassUveos_DoNothingModeDistance(&env->uveos, true);
|
||
}
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY);
|
||
} else {
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_WAIT_GNSS);
|
||
env->uveos.doNothing.mode = UVEOS_DO_NOTHING_DISABLED;
|
||
SystemDelayMs(10);
|
||
}
|
||
|
||
if (GsmWithGnss_IsGnssReady(&env->gsmWithGnss)) {
|
||
env->indication.mode = DEVICE_MODE_UVEOS_ERA_GNSS_READY;
|
||
} else {
|
||
env->indication.mode = DEVICE_MODE_UVEOS_ERA_WAIT_GNSS;
|
||
}
|
||
|
||
} else {
|
||
if (env->gsmWithGnss.gnss.currentRmc.status == 'A') {
|
||
if (ModemDataCollector_GetThisSubSystem(&env->systemSelector) == UVEOS) {
|
||
EraGlonassUveos_DoNothingModeDistance(&env->uveos, true);
|
||
}
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY);
|
||
} else {
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_WAIT_GNSS);
|
||
}
|
||
}
|
||
}
|
||
|
||
void Mma_gnssUpdateIndication(tMma *env) {
|
||
// Mma_gnssUpdateIndicationGetGnssState(env);
|
||
if (env->indication.mode != DEVICE_MODE_FAILURE) {
|
||
Mma_gnssUpdateIndicationGetGnssState(env);
|
||
}
|
||
if (env->indication.mode == DEVICE_MODE_UVEOS_UNDEFINDET) {
|
||
Mma_gnssUpdateIndicationGetGnssState(env);
|
||
}
|
||
}
|
||
|
||
static void Mma_UserTestMode(tMma *env,bool exitTestPlay) {
|
||
|
||
if (env->testing.queryUDSState->source == GSM_TEST) {
|
||
Mma_NetworkRequire(env);
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "reg_to_net.mp3", 4 * 1000);
|
||
}
|
||
|
||
EraGlonassUveos_DoNotingTestingStarted(&env->uveos);
|
||
|
||
if (DeviceTesting_RunUserTests(&env->testing) == true) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Пользовательское тестирование завершено")
|
||
if (!env->storage.nvm->device.factoryMode) {
|
||
SystemDelayMs(500);
|
||
Mma_AudioSubSystemRequire(env);
|
||
SystemDelayMs(500);
|
||
if(exitTestPlay == true) {
|
||
DeviceTesting_ExitTestPlay(&env->testing);
|
||
}
|
||
}
|
||
}
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY);
|
||
}
|
||
|
||
void Mma_RunUserTests(tMma *env, bool releaseAudioSubSystem) {
|
||
|
||
if (env->indication.mode == DEVICE_MODE_TESTING) {
|
||
return;
|
||
}
|
||
|
||
setGeneralGNSS(env,
|
||
CAN_GNSS_NO_CALL,
|
||
CAN_GNSS_NO_MALFUNCTIONS,
|
||
CAN_GNSS_NO_ROLLOVER_DETECT,
|
||
CAN_GNSS_CALL_TEST_ACTIVE
|
||
);
|
||
Mma_SetMode(env, DEVICE_MODE_TESTING);
|
||
|
||
Mma_AudioSubSystemRequire(env);
|
||
#if (AURUS_CAR_UI == 1)
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "runTestAurus.mp3", 4 * 1000);
|
||
#endif
|
||
|
||
vAsciiStringInit(step, &str_len, 5);
|
||
vAsciiStringAddDecimalInt64(step, &str_len, env->uveos.doNothing.movDist, 5);
|
||
eSubSystems subSystemsBuf = ModemDataCollector_GetThisSubSystem(&env->systemSelector);
|
||
|
||
if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_DISABLED) {
|
||
|
||
if (env->testing.queryUDSState->source != LEDS_TEST) {
|
||
#if (AURUS_CAR_UI == 1)
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "autoDiagnost.mp3", 5 * 1000);
|
||
#endif
|
||
#if (AURUS_CAR_UI == 0)
|
||
if (
|
||
(env->testing.audioHintsMode != HINTS_MINIMAL) &&
|
||
(env->testing.audioHintsMode != HINTS_NOT_ERA_EXIT)) {
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000);
|
||
}
|
||
if (env->testing.audioHintsMode == HINTS_NOT_ERA_EXIT) {
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000);
|
||
env->testing.audioHintsMode = HINTS_MINIMAL;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим пользовательского тестирования, отклонение дистанции=")
|
||
LoggerInfo(LOGGER, LOG_SIGN, step, str_len)
|
||
|
||
Mma_UserTestMode(env,releaseAudioSubSystem);
|
||
|
||
if(releaseAudioSubSystem == true) {
|
||
Mma_AudioSubSystemRelease(env);
|
||
}
|
||
|
||
env->testing.queryUDSState->commands = COM_INIT;
|
||
SystemSelector(&env->systemSwitcher, subSystemsBuf);
|
||
|
||
} else if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_MOVE_TO) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Переход в режим тестирования не возможен, Т.С. находится в движении, отклонение дистанции=")
|
||
LoggerInfo(LOGGER, LOG_SIGN, step, str_len)
|
||
} else if (env->uveos.doNothing.movePosition.valid == 0) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Данные GNSS не достоверны!")
|
||
}
|
||
|
||
env->testing.queryUDSState->state = QUERY_STOP;
|
||
|
||
if(releaseAudioSubSystem == true) {
|
||
setGeneralGNSS(env,
|
||
CAN_GNSS_NO_CALL,
|
||
CAN_GNSS_NO_MALFUNCTIONS,
|
||
CAN_GNSS_NO_ROLLOVER_DETECT,
|
||
CAN_GNSS_CALL_TEST_NOT_ACTIVE
|
||
);
|
||
}
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_UNDEFINDET);
|
||
}
|
||
|
||
|
||
void Mma_CheckingChangesGNSS_Antena(tMma *env) {
|
||
if (env->storage.nvm->device.useInternalAnt != env->power.interAntBufVal) {
|
||
Pwm_LNA_setMode(&env->power, env->storage.nvm->device.useInternalAnt);
|
||
}
|
||
env->power.interAntBufVal = env->storage.nvm->device.useInternalAnt;
|
||
}
|
||
|
||
void Mma_RunServiceMode(tMma *env) {
|
||
vAsciiStringInit(step, &str_len, 5);
|
||
vAsciiStringAddDecimalInt64(step, &str_len, env->uveos.doNothing.movDist, 5);
|
||
eSubSystems subSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector);
|
||
if (subSystemsTmp != TELEMATICA) {
|
||
if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) {
|
||
///* переключение в режим телематики
|
||
SystemSelector(&env->systemSwitcher, TELEMATICA);
|
||
EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_START);
|
||
}
|
||
}
|
||
|
||
if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_DISABLED) {
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_GARAG);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в сервисный режим, отклонение дистанции = ")
|
||
LoggerInfo(LOGGER, LOG_SIGN, step, str_len)
|
||
Mma_GarageMode(env);
|
||
} else if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_MOVE_TO) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Переход в сервисный режим не возможен, Т.С. находится в движении, отклонение дистанции=")
|
||
LoggerInfo(LOGGER, LOG_SIGN, step, str_len)
|
||
} else if (env->uveos.doNothing.movePosition.valid == 0) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Данные GNSS не достоверны!")
|
||
}
|
||
}
|
||
|
||
void Mma_UserInputSubstartButtonThreadStart(tMma *env) {
|
||
if (!env->threadSubstartChekButton.id) {
|
||
env->threadSubstartChekButton.id = osThreadNew(
|
||
(osThreadFunc_t) (Mma_UserInputSubstartButtonThread),
|
||
(void *) (env),
|
||
&env->threadSubstartChekButton.attr
|
||
);
|
||
}
|
||
}
|
||
|
||
void Mma_UserInputSubstartButtonThreadStop(tMma *env) {
|
||
if (osThreadTerminate(env->threadSubstartChekButton.id) == osOK) {
|
||
SystemDelayMs(100);
|
||
env->threadSubstartChekButton.id = NULL;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Поток предстартового опроса БИПа остановлен")
|
||
}
|
||
}
|
||
|
||
|
||
static _Noreturn void Mma_UserInputSubstartButtonThread(tMma *env) {
|
||
tUserInputButtonEvent buttonEvent = {0};
|
||
bool fl_isSend = false;
|
||
while (1) {
|
||
if (fl_isSend == false) {
|
||
if (EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable) > 0) {
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_SMS_TRANSMIT);
|
||
env->userInputSubstart = SUB_START_MODE_NOT_SEND_MSD;
|
||
}
|
||
fl_isSend = true;
|
||
}
|
||
if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
|
||
if (UserInputButtonEventIs(buttonEvent, UI_CUSTOM_BUTTON_TEST_MODE, FALL)) {
|
||
Mma_SetMode(env, DEVICE_MODE_TESTING);
|
||
env->userInputSubstart = SUB_START_MODE_TESTING;
|
||
} else {
|
||
if (UserInputButtonEventIs(buttonEvent, UI_CUSTOM_BUTTON_EMERGENCY, FALL)) {
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_MANUAL_BEGIN);
|
||
env->userInputSubstart = SUB_START_MODE_EMER;
|
||
}
|
||
}
|
||
}
|
||
|
||
SystemDelayMs(4);
|
||
}
|
||
}
|
||
|
||
|
||
void Mma_ClearParams(tMma *env) {
|
||
String32CopyStatic(&env->storage.nvm->gost.VIN, "00000000000000000");
|
||
}
|
||
|
||
void Mma_RunShortTest(tMma *env, bool blocEcall) {
|
||
eSubSystems eSubSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector);
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
|
||
if(blocEcall == false) {
|
||
AccompanModeStopThread(env);
|
||
}
|
||
|
||
// GsmWithGnss_InvalidateNetworkEnable(&env->gsmWithGnss, 0, true);
|
||
// Mma_NetworkRequire(env);
|
||
|
||
Mma_AudioSubSystemRequire(env);
|
||
|
||
env->queryUDSState.source = SPEAK_MICR_TEST;
|
||
env->testing.audioHintsMode = HINTS_NOT_ERA_EXIT;
|
||
|
||
SystemDelayMs(500);
|
||
Mma_RunUserTests(env, false);
|
||
SystemDelayMs(500);
|
||
|
||
// if(blocEcall == true) {
|
||
// env->queryUDSState.source = LEDS_TEST;
|
||
// env->testing.audioHintsMode = HINTS_MINIMAL;
|
||
// Mma_RunUserTests(env, false);
|
||
// }
|
||
|
||
env->testing.audioHintsMode = HINTS_NORMAL;
|
||
env->lastEventDevice = LAST_EVENT_TEST;
|
||
|
||
if(blocEcall == false) {
|
||
uint16_t bufTime = env->uveos.settings->TEST_REGISTRATION_PERIOD;
|
||
uint16_t bufManDialAttems = env->uveos.settings->ECALL_MANUAL_DIAL_ATTEMPTS;
|
||
env->uveos.settings->TEST_REGISTRATION_PERIOD = 1;
|
||
env->uveos.settings->ECALL_MANUAL_DIAL_ATTEMPTS = 1;
|
||
EraGlonassUveosDumper_ForceDump(env->uveos.dumper);
|
||
Mma_AudioSubSystemRequire(env);
|
||
DeviceTesting_TestingECool(&env->testing);
|
||
env->uveos.settings->TEST_REGISTRATION_PERIOD = bufTime;
|
||
env->uveos.settings->ECALL_MANUAL_DIAL_ATTEMPTS = bufManDialAttems;
|
||
EraGlonassUveosDumper_ForceDump(env->uveos.dumper);
|
||
}
|
||
if(env->storage.nvm->device.factoryMode != true){
|
||
DeviceTesting_ExitTestPlay(&env->testing);
|
||
}
|
||
Mma_AudioSubSystemRelease(env);
|
||
env->testing.audioHintsMode = HINTS_FULL;
|
||
SystemSelector(&env->systemSwitcher, eSubSystemsTmp);
|
||
AccompanModeStartThread(env);
|
||
}
|
||
|
||
void Mma_PassedMode(tMma *env) {
|
||
SystemSelector(&env->systemSwitcher, UNDEFANDET);
|
||
tUserInputButtonEvent buttonEvent = {0};
|
||
bool checStartEOL = false;
|
||
|
||
while ((DeviceTesting_VIN(&env->storage) != DEVICE_TESTING_CODE_PASSED) || (env->eolAcsess == true)) {
|
||
|
||
if (*env->comInt.Amplifier.playMode == true) {
|
||
Mma_AudioSubSystemRequire(env);
|
||
AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000);
|
||
*env->comInt.Amplifier.playMode = false;
|
||
Mma_AudioSubSystemRelease(env);
|
||
}
|
||
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_PASSIVE);
|
||
|
||
if (env->tm_FactoryMessage < SystemGetMs()) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Пассивный режим, сконфигурируйте устройство!")
|
||
// if (env->fl_isFacrotyMode == true) {
|
||
// LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
// "Устройство было в режиме производственного контроля, для отключения устройства отключите линию питания и зажигания")
|
||
// }
|
||
env->tm_FactoryMessage = SystemGetMs() + 8000;
|
||
}
|
||
|
||
if (env->checNetDeGeg == false) {
|
||
|
||
if (env->threadSubstartChekButton.id != NULL) {
|
||
Mma_UserInputSubstartButtonThreadStop(env);
|
||
}
|
||
env->checNetDeGeg = true;
|
||
}
|
||
|
||
if (env->state.GsmRegistartionStateMem == 0) {
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
|
||
// if(checNetReg == false) {
|
||
// if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 4000) == osOK) {
|
||
// AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt);
|
||
// osMutexRelease(env->gsmWithGnss.gsmAt.access);
|
||
// }
|
||
// }
|
||
|
||
checStartEOL = true;
|
||
// if( (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss,1000) == true) && (checNetReg == false) ){
|
||
// env->state.GsmRegistartionStateMem = 2;
|
||
// env->state.GsmRegistrationState = 2;
|
||
// }
|
||
//
|
||
// if( (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss,1000) == false) && (checNetReg == false) ){
|
||
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Выполнен запрос регистрации в сети, инициализатор - процедура EOL")
|
||
// checNetReg = true;
|
||
// if(GsmWithGnss_NetworkReconnect(&env->gsmWithGnss.gsmAt , 5) == AT_OK){
|
||
// if(GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss,2000) == true){
|
||
// env->state.GsmRegistartionStateMem = 2;
|
||
// env->state.GsmRegistrationState = 2;
|
||
// }
|
||
// }
|
||
//
|
||
// } else if(checNetReg == true) {
|
||
// if(tm_tt > SystemGetMs()){
|
||
// if(GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss,2000) == true){
|
||
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети инициализированная EOL получена")
|
||
// env->state.GsmRegistartionStateMem = 2;
|
||
// env->state.GsmRegistrationState = 2;
|
||
// }
|
||
// tm_tt = SystemGetMs()+10000;
|
||
// }
|
||
env->state.GsmRegistartionStateMem = 2;
|
||
env->state.GsmRegistrationState = 2;
|
||
// }
|
||
}
|
||
|
||
/**
|
||
* Проверка вызова тестирования
|
||
*/
|
||
/** НАЧАЛО **/
|
||
/** Проверка на вызов тестирования по кнопка **/
|
||
if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
|
||
if (UserInputButtonEventIs(buttonEvent, UI_CUSTOM_BUTTON_TEST_MODE, FALL)) {
|
||
UserButtons_Clear(env->testing.input);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Получен сигнал перехода в режим пользовательского тестирования код 1")
|
||
if (checStartEOL == true) {
|
||
checStartEOL = false;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование в режиме EOL")
|
||
eSubSystems eSubSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector);
|
||
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
|
||
setGeneralGNSS(env,
|
||
CAN_GNSS_NO_CALL,
|
||
CAN_GNSS_NO_MALFUNCTIONS,
|
||
CAN_GNSS_NO_ROLLOVER_DETECT,
|
||
CAN_GNSS_CALL_TEST_ACTIVE
|
||
);
|
||
|
||
env->testing.audioHintsMode = HINTS_NORMAL;
|
||
Mma_RunShortTest(env, false);
|
||
env->testing.audioHintsMode = HINTS_FULL;
|
||
|
||
setGeneralGNSS(env,
|
||
CAN_GNSS_NO_CALL,
|
||
CAN_GNSS_NO_MALFUNCTIONS,
|
||
CAN_GNSS_NO_ROLLOVER_DETECT,
|
||
CAN_GNSS_CALL_TEST_NOT_ACTIVE
|
||
);
|
||
|
||
EraGlonassMsdTable_Init(env->uveos.msdTable);
|
||
EraGlonassUveosDumper_ForceDump(env->uveos.dumper);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Данные о экстренных вызовах очищены из ПЗУ устройства")
|
||
|
||
if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 2000) == true) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети инициализированная EOL получена")
|
||
env->state.GsmRegistartionStateMem = 2;
|
||
env->state.GsmRegistrationState = 2;
|
||
}
|
||
|
||
SystemSelector(&env->systemSwitcher, eSubSystemsTmp);
|
||
|
||
env->state.GsmRegistartionStateMem = 0;
|
||
env->eolAcsess = false;
|
||
|
||
|
||
} else {
|
||
setGeneralGNSS(env,
|
||
CAN_GNSS_NO_CALL,
|
||
CAN_GNSS_NO_MALFUNCTIONS,
|
||
CAN_GNSS_NO_ROLLOVER_DETECT,
|
||
CAN_GNSS_CALL_TEST_ACTIVE
|
||
);
|
||
|
||
Mma_RunShortTest(env, false);
|
||
|
||
setGeneralGNSS(env,
|
||
CAN_GNSS_NO_CALL,
|
||
CAN_GNSS_NO_MALFUNCTIONS,
|
||
CAN_GNSS_NO_ROLLOVER_DETECT,
|
||
CAN_GNSS_CALL_TEST_NOT_ACTIVE
|
||
);
|
||
}
|
||
env->userInputSubstart = SUB_START_MODE_UNDEF;
|
||
UserButtons_Clear(env->testing.input);
|
||
}
|
||
}
|
||
/** Иначе очищаем полученные события нажатий и проверяем
|
||
* флаг предстартовой проверки событий на вызов тестирования по кнопкам
|
||
*/
|
||
else {
|
||
UserButtons_Clear(env->testing.input);
|
||
if (env->userInputSubstart == SUB_START_MODE_TESTING) {
|
||
env->userInputSubstart = SUB_START_MODE_UNDEF;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование в режиме EOL 2")
|
||
if (checStartEOL == true) {
|
||
checStartEOL = false;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование в режиме EOL 3")
|
||
eSubSystems eSubSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector);
|
||
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
|
||
setGeneralGNSS(env,
|
||
CAN_GNSS_NO_CALL,
|
||
CAN_GNSS_NO_MALFUNCTIONS,
|
||
CAN_GNSS_NO_ROLLOVER_DETECT,
|
||
CAN_GNSS_CALL_TEST_ACTIVE
|
||
);
|
||
|
||
env->testing.audioHintsMode = HINTS_NORMAL;
|
||
Mma_RunShortTest(env, false);
|
||
env->testing.audioHintsMode = HINTS_FULL;
|
||
|
||
setGeneralGNSS(env,
|
||
CAN_GNSS_NO_CALL,
|
||
CAN_GNSS_NO_MALFUNCTIONS,
|
||
CAN_GNSS_NO_ROLLOVER_DETECT,
|
||
CAN_GNSS_CALL_TEST_NOT_ACTIVE
|
||
);
|
||
|
||
EraGlonassMsdTable_Init(env->uveos.msdTable);
|
||
EraGlonassUveosDumper_ForceDump(env->uveos.dumper);
|
||
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Данные о экстренных вызовах очищены из ПЗУ устройства")
|
||
|
||
if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 2000) == true) {
|
||
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети инициализированная EOL получена")
|
||
env->state.GsmRegistartionStateMem = 2;
|
||
env->state.GsmRegistrationState = 2;
|
||
}
|
||
|
||
SystemSelector(&env->systemSwitcher, eSubSystemsTmp);
|
||
|
||
env->state.GsmRegistartionStateMem = 0;
|
||
env->eolAcsess = false;
|
||
} else {
|
||
setGeneralGNSS(env,
|
||
CAN_GNSS_NO_CALL,
|
||
CAN_GNSS_NO_MALFUNCTIONS,
|
||
CAN_GNSS_NO_ROLLOVER_DETECT,
|
||
CAN_GNSS_CALL_TEST_ACTIVE
|
||
);
|
||
|
||
Mma_RunShortTest(env, false);
|
||
|
||
setGeneralGNSS(env,
|
||
CAN_GNSS_NO_CALL,
|
||
CAN_GNSS_NO_MALFUNCTIONS,
|
||
CAN_GNSS_NO_ROLLOVER_DETECT,
|
||
CAN_GNSS_CALL_TEST_NOT_ACTIVE
|
||
);
|
||
}
|
||
}
|
||
}
|
||
/**
|
||
* Проверка вызова тестирования
|
||
*/
|
||
/** КОНЕЦ **/
|
||
|
||
Mma_RunTests(env);
|
||
|
||
if (checStartEOL == false) {
|
||
Mma_SubstartTelematica(env);
|
||
}
|
||
|
||
/**
|
||
* Проверка отключения для производственного контроля или после выхода из него
|
||
* Если зажигание отключено и
|
||
* Напряжение сети меньше 7 Вольт
|
||
* Переходим к процедуре отключения
|
||
*/
|
||
if (env->fl_isFacrotyMode == true) {
|
||
if (
|
||
(GpioPinGet(&env->power.powerSusystem->main.ignition) == false) &&
|
||
(env->power.powerSusystem->boardPower.currentBoardVoltage < 7000)
|
||
) {
|
||
Mma_Shutdown(env);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Если мы не в режиме производственного контроля
|
||
* и не были в нем в текущем включении
|
||
* Осуществляется стандартная проверка отключения
|
||
*/
|
||
if ((env->fl_isFacrotyMode != true) /* && (checStartEOL == false) */) {
|
||
Mma_CheckShutdown(env);
|
||
}
|
||
SystemDelayMs(100);
|
||
|
||
}
|
||
}
|
||
|
||
|
||
void setGeneralGNSS(tMma *env,
|
||
eCanGnssCallByButton GNSS_Call_By_button,
|
||
eCanGnssStatus GNSS_Status,
|
||
eCanGnssCallAuto GNSS_Call_Auto,
|
||
eCanGnssCallTest GNSS_Call_Test
|
||
) {
|
||
if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) {
|
||
env->GNSS_General.GNSS_Call_By_button = GNSS_Call_By_button;
|
||
env->GNSS_General.GNSS_Status = GNSS_Status;
|
||
env->GNSS_General.GNSS_Call_Auto = GNSS_Call_Auto;
|
||
env->GNSS_General.GNSS_Call_Test = GNSS_Call_Test;
|
||
}
|
||
}
|
||
|
||
|
||
static _Noreturn void Mma_Thread(tMma *env) {
|
||
env->tmStart = SystemGetMs();
|
||
uint32_t bufTm = 0;
|
||
//Запуск устройства
|
||
Mma_InitStage(env);
|
||
AccompanModeStartThread(env);
|
||
size_t size = xPortGetMinimumEverFreeHeapSize();
|
||
uint32_t sizeStorage = sizeof(tDeviceDataNonVolatile);
|
||
LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Свободно %u байт в куче. Размер хранилища %u", size, sizeStorage)
|
||
|
||
tDeviceModes *indicationState = UserIndication_GetMode(env);
|
||
tUserInputButtonEvent buttonEvent = {0};
|
||
tUveosEmergencyEvent emergencyEvent = {0};
|
||
|
||
while (env->storage.nvm->device.factoryMode) {
|
||
SystemDelayMs(100);
|
||
}
|
||
|
||
if (env->storage.nvm->device.serviseMode) {
|
||
Mma_UserInputSubstartButtonThreadStop(env);
|
||
Mma_RunServiceMode(env);
|
||
Mma_UserInputSubstartButtonThreadStart(env);
|
||
}
|
||
|
||
if (!env->storage.nvm->device.factoryMode) {
|
||
Mma_PassedMode(env);
|
||
env->userInputSubstart = SUB_START_MODE_UNDEF;
|
||
UserButtons_Clear(env->testing.input);
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_WAIT_GNSS);
|
||
EraGlonassUveosDumper_ForceDump(env->uveos.dumper);
|
||
}
|
||
|
||
uint32_t noSendMsdCount = EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable);
|
||
if (env->storage.nvm->gost.notGost.ECALL_DEBUG_MODE) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "ДОСТУП ЗАБЛОКИРОВАН, СИСТЕМА В РЕЖИМЕ ОТЛАДКИ")
|
||
noSendMsdCount = 0;
|
||
}
|
||
|
||
if (
|
||
(noSendMsdCount > 0) &&
|
||
(osMutexAcquire(env->mux_factoryMode, 5000) == osOK)
|
||
) {
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Обнаружены не обработанные МНД, инициализирована процедура переотправки")
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
|
||
uint32_t tm_t = SystemGetMs() + 10000;
|
||
while ((env->fl_iniSysIsDone != true) && (tm_t > SystemGetMs())) {
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN,
|
||
"Обнаружены не обработанные МНД, ожидание инициализации системы для дальнейшей их обработки")
|
||
SystemDelayMs(2000);
|
||
}
|
||
|
||
uint8_t bufUserInputSubstart = env->userInputSubstart;
|
||
eSubSystems eSubSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector);
|
||
|
||
if (GsmWithGnss_NetworkSetStateInnaterups(&env->gsmWithGnss, 4, 40) == AT_OK) {
|
||
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Регистрация в сети выполнена")
|
||
AccompanModeStopThread(env);
|
||
EraGlonassUveos_ProcessingEra(&env->uveos);
|
||
AccompanModeStartThread(env);
|
||
|
||
if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) {
|
||
AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС")
|
||
osMutexRelease(env->gsmWithGnss.gsmAt.access);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_NetworkSetStateInnaterups 0")
|
||
}
|
||
|
||
if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) {
|
||
AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt);
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Регистрация в сети отключена")
|
||
osMutexRelease(env->gsmWithGnss.gsmAt.access);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_NetworkSetStateInnaterups 1")
|
||
}
|
||
|
||
noSendMsdCount = EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable);
|
||
if (noSendMsdCount == 0) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Не отправленные экстренные события обработаны полностью, данные из ПЗУ очищены")
|
||
EraGlonassMsdTable_Init(env->uveos.msdTable);
|
||
EraGlonassUveosDumper_ForceDump(env->uveos.dumper);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Остались не обработанные МНД в хранилище")
|
||
}
|
||
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует")
|
||
}
|
||
|
||
ModemDataCollector_SetThisSubSystem(&env->systemSelector, eSubSystemsTmp);
|
||
env->userInputSubstart = bufUserInputSubstart;
|
||
osMutexRelease(env->mux_factoryMode);
|
||
}
|
||
|
||
Mma_UserInputSubstartButtonThreadStop(env);
|
||
|
||
if (env->userInputSubstart == SUB_START_MODE_EMER) {
|
||
env->userInputSubstart = SUB_START_MODE_UNDEF;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Экстренный вызов, предстартовый поток")
|
||
Mma_EcallManual(env);
|
||
} else {
|
||
if (env->userInputSubstart == SUB_START_MODE_TESTING) {
|
||
env->userInputSubstart = SUB_START_MODE_UNDEF;
|
||
env->testing.queryUDSState->state = QUERY_BUSY;
|
||
env->queryUDSState.source = FULL_TESTS;
|
||
AccompanModeStopThread(env);
|
||
Mma_RunUserTests(env, true);
|
||
AccompanModeStopThread(env);
|
||
env->testing.queryUDSState->state = QUERY_STOP;
|
||
}
|
||
}
|
||
|
||
if (env->storage.nvm->gost.notGost.ECALL_DEBUG_MODE) {
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
|
||
Mma_AudioSubSystemRequire(env);
|
||
}
|
||
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск главного цикла")
|
||
|
||
for (;;) {
|
||
|
||
Mma_SubstartTelematica(env);
|
||
|
||
while (env->storage.nvm->device.factoryMode) {
|
||
SystemDelayMs(1000);
|
||
}
|
||
|
||
Mma_UserInputSubstartButtonThreadStop(env);
|
||
|
||
AccompanModeStartThread(env);
|
||
Mma_SetMode(env, *indicationState);
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Обновляем индикацию")
|
||
|
||
Mma_CheckingChangesGNSS_Antena(env);
|
||
|
||
if ((env->uveos.timings.lastInMemTransmit < SystemGetMs()) && (env->uveos.settings->notGost.ECALL_DEBUG_MODE)) {
|
||
if (bufTm < SystemGetMs()) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Периодическая проверка необходимости повторной отправки МНД НЕ ВЫПОЛНЕНА, СИСТЕМА В ДЭБАГ РЕЖИМЕ")
|
||
bufTm = SystemGetMs() + 4000;
|
||
}
|
||
}
|
||
|
||
if ((env->uveos.timings.lastInMemTransmit < SystemGetMs()) &&
|
||
(!env->uveos.settings->notGost.ECALL_DEBUG_MODE)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Периодическая проверка необходимости повторной отправки МНД")
|
||
|
||
noSendMsdCount = EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable);
|
||
if (env->storage.nvm->gost.notGost.ECALL_DEBUG_MODE) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "ДОСТУП ЗАБЛОКИРОВАН, СИСТЕМА В РЕЖИМЕ ОТЛАДКИ")
|
||
noSendMsdCount = 0;
|
||
}
|
||
|
||
if ((noSendMsdCount > 0) && (osMutexAcquire(env->mux_factoryMode, 5000) == osOK)) {
|
||
eSubSystems subSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector);
|
||
|
||
if (subSystemsTmp != UVEOS) {
|
||
SystemSelector(&env->systemSwitcher, UVEOS);
|
||
|
||
}
|
||
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Обнаружены не обработанные МНД, проверка регистрации в сети")
|
||
if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 2000)) {
|
||
AccompanModeStopThread(env);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует")
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN,
|
||
"Производится обработка не переданных МНД, передача по средствам PDU пакетов")
|
||
EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС")
|
||
|
||
if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) {
|
||
AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
|
||
SystemDelayMs(500);
|
||
AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено")
|
||
osMutexRelease(env->gsmWithGnss.gsmAt.access);
|
||
}
|
||
|
||
AccompanModeStartThread(env);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует, попытка регистрации код 3")
|
||
if (GsmWithGnss_NetworkSetStateInnaterups(&env->gsmWithGnss, 5, 5000) == AT_OK) {
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть присутствует")
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN,
|
||
"Производится обработка не переданных МНД, передача по средствам PDU пакетов")
|
||
EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС")
|
||
|
||
if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) {
|
||
AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
|
||
SystemDelayMs(500);
|
||
AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено")
|
||
osMutexRelease(env->gsmWithGnss.gsmAt.access);
|
||
}
|
||
|
||
SystemDelayMs(500);
|
||
|
||
if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) {
|
||
AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
|
||
SystemDelayMs(500);
|
||
AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено")
|
||
osMutexRelease(env->gsmWithGnss.gsmAt.access);
|
||
}
|
||
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено")
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Периодическая проверка необходимости повторной отправки МНД не выполнена, сеть отсутствует")
|
||
}
|
||
}
|
||
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Обработка не отправленных МНД выполнена")
|
||
SystemSelector(&env->systemSwitcher, subSystemsTmp);
|
||
|
||
osMutexRelease(env->mux_factoryMode);
|
||
}
|
||
|
||
env->uveos.timings.lastInMemTransmit =
|
||
SystemGetMs() + (env->uveos.settings->INT_MEM_TRANSMIT_INTERVAL * 60 * 1000);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Время периодическая проверки повторной отправки МНД обновлено")
|
||
}
|
||
|
||
if (UveosEmergencyEvent_GetNext(&env->crashDetect.emergencyEvents, &emergencyEvent, 0)) {
|
||
if (env->storage.nvm->gost.CRASH_SIGNAL_INTERNAL == 1) {
|
||
if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) {
|
||
|
||
if (env->crashDetect.carCrashDetection.asi15.impactDetected) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Тип события - столкновение")
|
||
env->lastEventDevice = LAST_EVENT_IMPACT;
|
||
}
|
||
if (env->crashDetect.carCrashDetection.flip.flipDetected) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Тип события - переворот")
|
||
env->lastEventDevice = LAST_EVENT_FLIP;
|
||
}
|
||
|
||
Mma_EcallAutomatic(env, emergencyEvent);
|
||
Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY);
|
||
osMutexRelease(env->mux_factoryMode);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата Mma_EcallAutomatic")
|
||
}
|
||
}
|
||
}
|
||
|
||
if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
|
||
if (UserInputButtonEventIs(buttonEvent, UI_CUSTOM_BUTTON_TEST_MODE, FALL)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Получен сигнал перехода в режим пользовательского тестирования код 3")
|
||
|
||
if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) {
|
||
#if (AURUS_CAR_UI == 1)
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование")
|
||
bool fl_audioHids = env->uveos.fl_audioHids;
|
||
env->uveos.fl_audioHids = false;
|
||
|
||
env->testing.queryUDSState->state = QUERY_BUSY;
|
||
env->queryUDSState.source = INTERNAL_ONE_TEST;
|
||
env->lastEventDevice = LAST_EVENT_TEST;
|
||
Mma_RunUserTests(env,true);
|
||
osMutexRelease(env->mux_factoryMode);
|
||
env->testing.queryUDSState->state = QUERY_STOP;
|
||
env->uveos.fl_audioHids = fl_audioHids;
|
||
#endif
|
||
#if (AURUS_CAR_UI == 0)
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование")
|
||
env->testing.queryUDSState->state = QUERY_BUSY;
|
||
env->queryUDSState.source = FULL_TESTS;
|
||
env->lastEventDevice = LAST_EVENT_TEST;
|
||
AccompanModeStopThread(env);
|
||
Mma_RunUserTests(env,true);
|
||
AccompanModeStartThread(env);
|
||
osMutexRelease(env->mux_factoryMode);
|
||
env->testing.queryUDSState->state = QUERY_STOP;
|
||
#endif
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата ( Mma_RunUserTests )")
|
||
}
|
||
}
|
||
|
||
if (UserInputButtonEventIs(buttonEvent, UI_CUSTOM_BUTTON_EMERGENCY, FALL)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Нажата кнопка экстренного вызова")
|
||
if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) {
|
||
env->lastEventDevice = LAST_EVENT_MANUAL;
|
||
//начало-----------------Обновление счетчиков телематики (для отладки)--------------------------------------
|
||
if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) {
|
||
EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_COUNTER_2);
|
||
}
|
||
//конец------------------Обновление счетчиков телематики (для отладки)--------------------------------------
|
||
Mma_EcallManual(env);
|
||
osMutexRelease(env->mux_factoryMode);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата Mma_EcallManual")
|
||
}
|
||
} else if (UserInputButtonEventIsBetween(buttonEvent, UI_VIRT_BUTTON_ADDITIONAL, RAISE, SERVICE_MODE_MIN, SERVICE_MODE_MAX)) {
|
||
if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов сервисного режима ")
|
||
Mma_RunServiceMode(env);
|
||
osMutexRelease(env->mux_factoryMode);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата Mma_RunServiceMode")
|
||
}
|
||
}
|
||
}
|
||
|
||
if (env->fl_iniSysIsDone == true) {
|
||
if ((EraGlonassUveos_IsAllowInCall(&env->uveos) == true) && (env->gsmWithGnss.urc.ring)) {
|
||
if (GsmWithGnss_isInpCallActive(&env->gsmWithGnss)) {
|
||
if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) {
|
||
Mma_ProcessCallAnswer(env);
|
||
env->gsmWithGnss.urc.ring = false;
|
||
osMutexRelease(env->mux_factoryMode);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата Mma_ProcessCallAnswer 1")
|
||
}
|
||
}
|
||
}
|
||
if ((EraGlonassUveos_IsAllowInCall(&env->uveos) == false) && (env->gsmWithGnss.urc.ring)) {
|
||
if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Была попытка дозвона на устройство с завершённым таймером ожидания входящего вызова")
|
||
AtGsmHangUpCall(&env->gsmWithGnss.gsmAt);
|
||
env->gsmWithGnss.urc.ring = false;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Попытка дозвона прекращена принудительно")
|
||
osMutexRelease(env->mux_factoryMode);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата Mma_ProcessCallAnswer 2")
|
||
}
|
||
}
|
||
}
|
||
|
||
eSubSystems subSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector);
|
||
if (subSystemsTmp == UVEOS) {
|
||
if (EraGlonassUveos_IsRequireNetwork(&env->uveos)) {
|
||
Mma_SetNetworkRegistration(env, true);
|
||
} else {
|
||
Mma_SetNetworkRegistration(env, false);
|
||
}
|
||
}
|
||
|
||
if (subSystemsTmp == UVEOS) {
|
||
if (Mma_CheckIncomingSms(env) == AT_TIMEOUT) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Проведена проверка входящих PDU пакетов")
|
||
}
|
||
}
|
||
// Mma_Shutdown(env);
|
||
Mma_CheckShutdown(env);
|
||
Mma_RunTests(env);
|
||
|
||
SystemDelayMs(40);
|
||
}
|
||
}
|
||
|
||
void Mma_StartThread(tMma *env) {
|
||
if (!env->thread.id) {
|
||
env->thread.id = osThreadNew((osThreadFunc_t) (Mma_Thread), (void *) (env), &env->thread.attr);
|
||
} else {
|
||
osThreadResume(env->thread.id);
|
||
}
|
||
}
|