// 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);
    }
}