commit af875d4875977e77a844af8f8b6d836c59c5af72
Author: cfif <cham-zod@mail.ru>
Date:   Wed Dec 4 13:10:47 2024 +0300

    Init

diff --git a/MainModesArbiter.c b/MainModesArbiter.c
new file mode 100644
index 0000000..3f402c2
--- /dev/null
+++ b/MainModesArbiter.c
@@ -0,0 +1,687 @@
+//
+// 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 "EgtsProcessing.h"
+//#include "testCan.h"
+
+#define LOG_SIGN "Главн."
+#define LOGGER &env->slog.logger
+
+size_t str_len = 0;
+char step[5];
+
+void Mma_Init(
+        tMma *env,
+        tGpios *gpios,
+        tSerialPorts *serialPorts,
+        tI2cPorts *i2cPorts,
+        tSpiPorts *spiPorts,
+        tAdcs *adcs,
+        tStorageOnFlash *flash,
+        tRtc *rtc
+) {
+    env->gpios = gpios;
+    env->serialPorts = serialPorts;
+    env->i2cPorts = i2cPorts;
+    env->spiPorts = spiPorts;
+    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 = 0;
+    env->flIgn = false;
+    env->kzModeBloc = false;
+}
+
+
+void Mma_Shutdown(tMma *env) {
+    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, "Возможно произошло повторное включение пользователем")
+    SystemDelayMs(5000);
+    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 = AdcGet(&env->adcs->batteryIo, 10);
+            volt = (float) single / 1000;
+            if (volt < 2.8) {
+                Mma_Shutdown(env);
+            }
+        }
+    }
+}
+
+void Mma_CheckShutdown(tMma *env, bool fastBlackOut) {
+    bool statShutdown = Pwm_IsShutdownRequired(&env->power);
+    bool statStandUp = EraGlonassUveos_IsStandby(&env->uveos);
+
+    if (statShutdown && (!statStandUp)) {
+        Mma_Shutdown(env);
+    }
+
+    Mma_CheckShutdownIsBattary(env);
+}
+
+static void Mma_SetNetworkRegistration(tMma *env, bool value) {
+#ifdef USE_GSM_AND_GNSS_TELIT
+    GsmWithGnss_SetNetworkRegistration(&env->gsmWithGnss, value);
+#endif
+#ifdef USE_GSM_AND_GNSS_SIMCOM
+    Gsm_SetNetworkRegistration(&env->gsm, value);
+#endif
+}
+
+static bool Mma_WaitNetworkRegistration(tMma *env) {
+#ifdef USE_GSM_AND_GNSS_TELIT
+    return GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 35000);
+#endif
+#ifdef USE_GSM_AND_GNSS_SIMCOM
+    return Gsm_WaitNetworkRegistration(&env->gsm);
+#endif
+}
+
+void Mma_AudioSignal(tMma *env, uint8_t count, uint16_t timeout) {
+#ifdef USE_GSM_AND_GNSS_TELIT
+    for (uint8_t i = 0; i < count; i++) {
+        if (AtGsmSetOpenAudioLoop(&env->gsmWithGnss.gsmAt, 1)) {
+            SystemDelayMs(timeout);
+            AtGsmSetOpenAudioLoop(&env->gsmWithGnss.gsmAt, 0);
+        }
+        SystemDelayMs(timeout);
+    }
+#endif
+#ifdef USE_GSM_AND_GNSS_SIMCOM
+    for (uint8_t i = 0; i < count; i++) {
+        if (AtGsmSetOpenAudioLoop(&env->gsm.gsmAt, 1)) {
+            SystemDelayMs(timeout);
+            AtGsmSetOpenAudioLoop(&env->gsm.gsmAt, 0);
+        }
+        SystemDelayMs(timeout);
+    }
+#endif
+
+}
+
+void Mma_GarageMode(tMma *env) {
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим Гараж")
+    GpioPinEnable(&env->power.pins->main.garage);
+
+    env->storage.nvm.device.garageMode = true;
+    DeviceStorage_ForceDump(&env->storage);
+
+    EraGlonassUveos_GarageStarted(&env->uveos);
+    tUserInputButtonEvent buttonEvent;
+    while (1) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим Гараж")
+
+        if (env->storage.runtime.enableGnssUpdate) {
+//            GsmWithGnss_GetNevData(&env->gsmWithGnss, 600);
+            AtGsm_Gsnss_GetNMEA_Pack(&env->gsmWithGnss, 400);
+            EraGlonassUveos_DoNothingModeDistance(&env->uveos, false);
+        }
+
+        if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_DISABLED) {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Автоматический выход из режима Гараж")
+            GpioPinDisable(&env->power.pins->main.garage);
+            env->storage.nvm.device.garageMode = false;
+            DeviceStorage_ForceDump(&env->storage);
+            EraGlonassUveos_DoNotingReset(&env->uveos);
+            return;
+        }
+
+        if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
+            if (UserInputButtonEventIsBetween(buttonEvent, UI_BUTTON_ADDITIONAL, RAISE, 10000, 0xFFFF)) {
+                LoggerInfoStatic(LOGGER, LOG_SIGN, "Пользовательский выход из режима Гараж")
+                GpioPinDisable(&env->power.pins->main.garage);
+                env->storage.nvm.device.garageMode = false;
+                DeviceStorage_ForceDump(&env->storage);
+                EraGlonassUveos_DoNotingReset(&env->uveos);
+                return;
+            }
+        }
+        if (DeviceTesting_Always(&env->testing)) {
+            Mma_SetMode(env, DEVICE_MODE_FAILURE);
+        } else {
+            Mma_SetMode(env, DEVICE_MODE_UVEOS_GARAG);
+        }
+
+        Mma_CheckShutdown(env, true);
+        SystemDelayMs(1000);
+    }
+}
+void Mma_NetworkAndAudioRequireKz(tMma *env) {
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Включаем звук");
+    Pwm_AudioEnable(&env->power);
+    //todo пока что включен всегда
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Поднимаем сигнал MUTE");
+    Pwm_SetMute(&env->power, true);
+}
+
+void Mma_NetworkAndAudioRequire(tMma *env) {
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Включаем звук");
+    Pwm_AudioEnable(&env->power);
+    //todo пока что включен всегда
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Поднимаем сигнал MUTE");
+    Pwm_SetMute(&env->power, true);
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Включаем регистрацию в сети");
+
+    Mma_SetNetworkRegistration(env, true);
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Ждем сеть...");
+
+    if (Mma_WaitNetworkRegistration(env)) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "зарегестрировались");
+    } else {
+        LoggerErrorStatic(LOGGER, LOG_SIGN, "нет сети");
+    };
+}
+
+static void Mma_NetworkAndAudioRelease(tMma *env) {
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Выключаем сигнал MUTE");
+    Pwm_SetMute(&env->power, false);
+    uint32_t t = SystemGetMs() + 200;
+    while (t > SystemGetMs()){}
+}
+
+void Mma_EcallManual(tMma *env) {
+    EraGlonassUveos_SetTimings(&env->uveos);
+    Mma_SetMode(env, DEVICE_MODE_UVEOS_CALL_INITIATE);
+    Mma_NetworkAndAudioRequire(env);
+    GpioPinEnable(&env->power.pins->main.ecall);
+    env->uveos.currentMsd->msd.MSD_Data.msgId = 1;
+    EraGlonassUveos_ManualEmergencyCall(&env->uveos, false);
+    GpioPinDisable(&env->power.pins->main.ecall);
+
+    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 0);
+    SystemDelayMs(500);
+    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 1);
+
+    Mma_NetworkAndAudioRelease(env);
+}
+
+void Mma_EcallManualKZ(tMma *env) {
+    EraGlonassUveos_SetTimings(&env->uveos);
+    Mma_SetMode(env, DEVICE_MODE_UVEOS_CALL_INITIATE);
+    Mma_NetworkAndAudioRequireKz(env);
+    GpioPinEnable(&env->power.pins->main.ecall);
+    env->uveos.currentMsd->msd.MSD_Data.msgId = 1;
+    EraGlonassUveos_ManualEmergencyCall(&env->uveos, true);
+    GpioPinDisable(&env->power.pins->main.ecall);
+
+    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 0);
+    SystemDelayMs(500);
+    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 1);
+
+    Mma_NetworkAndAudioRelease(env);
+}
+
+void Mma_gnssUpdate(tMma *env, eDeviceModes *deviceModes) {
+    LoggerTraceStatic(LOGGER, LOG_SIGN, "Обновление ГНСС")
+
+    if (env->storage.runtime.enableGnssUpdate == true){
+        EraGlonassUveosNavData location;
+
+        if((*deviceModes != DEVICE_MODE_TESTING) && (*deviceModes != DEVICE_MODE_UVEOS_GARAG) ) {
+            GsmWithGnss_GetNevData(&env->gsmWithGnss, 600);
+            AtGsm_Gsnss_GetLastActualNavData(&env->gsmWithGnss, &location, 1);
+
+            if (env->gsmWithGnss.gnss.currentRmc.status == 'A') {
+                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;
+            }
+
+            *deviceModes = GsmWithGnss_IsGnssReady(&env->gsmWithGnss) ?
+                           DEVICE_MODE_UVEOS_ERA_GNSS_READY :
+                           DEVICE_MODE_UVEOS_ERA_WAIT_GNSS;
+        } else {
+            AtGsm_Gsnss_GetLastActualNavData(&env->gsmWithGnss, &location, 0);
+        }
+
+    } else {
+        *deviceModes = DEVICE_MODE_UVEOS_ERA_WAIT_GNSS;
+    }
+}
+
+void Mma_EcallAutomatic(tMma *env, tUveosEmergencyEvent emergencyEvent) {
+
+    EraGlonassUveos_SetTimings(&env->uveos);
+
+    Pwm_AudioEnable(&env->power);
+    Mma_SetMode(env, DEVICE_MODE_UVEOS_CALL_INITIATE);
+    Mma_NetworkAndAudioRequire(env);
+
+    GpioPinEnable(&env->power.pins->main.ecall);
+    Mma_AudioSignal(env, 1, 500);
+    GsmWithGnss_GetNevData(&env->gsmWithGnss, 600);
+
+    eEraGlonassUveos_EcallProcessingResult res = EraGlonassUveos_ProcessingEmergencyEvent(&env->uveos, &emergencyEvent);
+
+    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 0);
+    SystemDelayMs(1000);
+    AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 1);
+
+    GpioPinDisable(&env->power.pins->main.ecall);
+    Mma_NetworkAndAudioRelease(env);
+}
+
+static void Mma_UserTestMode(tMma *env) {
+    Mma_NetworkAndAudioRequire(env);
+    Mma_SetNetworkRegistration(env, true);
+    AtGsm_Gsnss_GetNMEA_Pack(&env->gsmWithGnss, 500);
+    EraGlonassUveos_TestingStarted(&env->uveos);
+
+    if (DeviceTesting_RunUserTests(&env->testing) == true) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Пользовательское тестирование завершено");
+        DeviceTesting_ExitTestPlay(&env->testing);
+    }
+    env->gsmWithGnss.isBusy = false;
+    Mma_NetworkAndAudioRelease(env);
+}
+
+static void Mma_ProcessCallAnswer(tMma *env) {
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Включаем звук");
+    Pwm_AudioEnable(&env->power);
+    GpioPinEnable(&env->power.pins->main.ecall);
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Поднимаем сигнал MUTE");
+    Pwm_SetMute(&env->power, true);
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Получен вызов от оператора");
+    AudioPlayer_PlayStatic(&env->gsmWithGnss.audioPlayer, "audio_on", 8*1000);
+    SystemDelayMs(500);
+    AtGsmAnswer(&env->gsmWithGnss.gsmAt);
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов от оператора принят");
+    Mma_SetMode(env, DEVICE_MODE_UVEOS_CALL_ACTIVE);
+    bool wasNewSetMsd = false;
+    bool wasResent = false;
+    bool mndSendFlag = true;
+
+//    tMsdEncoded msdEncoded;
+//    env->uveos.currentMsd->msd.MSD_Data.msgId = 1;
+//    setMsdToPull(&env->uveos, &mndSendFlag, &wasNewSetMsd, &wasResent, &msdEncoded);
+    while (GsmWithGnss_isInpCallActive(&env->gsmWithGnss)) {
+        SystemDelayMs(500);
+    }
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов от оператора завершён");
+    while (AtGsmHangUpCall(&env->gsmWithGnss.gsmAt) == AT_OK) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "поднят HangUp");
+        GsmWithGnss_ResetRing(&env->gsmWithGnss);
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Выполнен сброс Ринга");
+        Pwm_AudioDisable(&env->power);
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Питание УНЧ отключено");
+        Mma_NetworkAndAudioRelease(env);
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Сигнал MUTE бортовой сети отключен");
+        Pwm_SetMute(&env->power, false);
+        GpioPinDisable(&env->power.pins->main.ecall);
+        SystemDelayMs(500);
+        break;
+    }
+}
+
+
+void Mma_TestingThread(tMma *env) {
+    eDeviceModes indicationState;
+    while (1) {
+//        Mma_gnssUpdate(env, &indicationState);
+
+        if (DeviceTesting_Always(&env->testing)) {
+            indicationState = DEVICE_MODE_FAILURE;
+        };
+
+        if (DeviceTesting_Periodical(&env->testing)) {
+            indicationState = DEVICE_MODE_FAILURE;
+        };
+
+        Mma_SetMode(env, indicationState);
+        SystemDelayMs(10);
+    }
+}
+
+static _Noreturn void Mma_Thread(tMma *env) {
+    RCC_EnableAPB1PeriphClk(RCC_APB1_PERIPH_PWR,ENABLE);
+    PWR_BackupAccessEnable(ENABLE);
+    RCC_EnableBackupReset(DISABLE);
+
+    //Запуск устройства
+    Mma_InitStage(env);
+
+    EgtsProcessing_Init(
+            &env->egtsProcessing,
+            &env->storage,
+            &env->power.pins->main.ignition,
+            &env->gsmWithGnss,
+                &env->rtc->rtcIo,
+                &env->slog
+    );
+
+    EgtsProcessing_Start(&env->egtsProcessing);
+
+    size_t size = xPortGetMinimumEverFreeHeapSize();
+    uint32_t sizeStorage = sizeof(tDeviceDataNonVolatile);
+    LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Свободно %u байт в куче. Размер хранилища %u", size, sizeStorage);
+
+    eDeviceModes indicationState;
+    tUserInputButtonEvent buttonEvent;
+    tUveosEmergencyEvent emergencyEvent;
+
+    if (env->storage.nvm.device.garageMode) {
+        Mma_GarageMode(env);
+    }
+
+    while (!EraGlonassUveos_IsEraAllowed(&env->uveos)) {
+        Mma_SetMode(env, DEVICE_MODE_UVEOS_PASSIVE);
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Пассивный режим, сконфигурируйте устройство!")
+
+        if (DeviceTesting_Always(&env->testing)) {
+            Mma_SetMode(env, DEVICE_MODE_FAILURE);
+        } else {
+            Mma_SetMode(env, DEVICE_MODE_UVEOS_PASSIVE);
+        }
+
+        LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем нажатия кнопок")
+        if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
+            if (UserInputButtonEventIsBetween(buttonEvent, UI_BUTTON_ADDITIONAL, RAISE, 3000, 10000)) {
+                LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим пользовательского тестирования")
+                Mma_SetMode(env, DEVICE_MODE_TESTING);
+                Mma_UserTestMode(env);
+            }
+        }
+
+        if (!GpioPinGet(&env->power.pins->main.ignition) && (env->indication.mode == DEVICE_MODE_UVEOS_PASSIVE)) {
+            env->power.shutdownDelay = 2000;
+            Mma_Shutdown(env);
+        }
+
+        Mma_CheckShutdown(env, true);
+        SystemDelayMs(1000);
+    }
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск главного цикла")
+
+    LoggerTraceStatic(LOGGER, LOG_SIGN, "Обработка режима ЭРА внутри УВЭОС")
+//    Mma_SetNetworkRegistration(env, true);
+//    EraGlonassUveos_ProcessingEra(&env->uveos);
+//    Mma_SetNetworkRegistration(env, false);
+    volatile uint32_t noSendMsdCount = EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable);
+    if (noSendMsdCount > 0) {
+        if (GsmWithGnss_NetworkEnableInnaterups(&env->gsmWithGnss, 4, 10000) == AT_OK) {
+            LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть включена")
+            EraGlonassUveos_ProcessingEra(&env->uveos);
+            AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
+            SystemDelayMs(5000);
+            AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
+            AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt);
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует");
+        }
+    }
+    Pwm_AudioDisable(&env->power);
+    LoggerTraceStatic(LOGGER, LOG_SIGN, "Звуковой усилитель отключён")
+
+
+//    Mma_StartTestThreadStart(env);
+    for (;;) {
+
+        Mma_ColorBip(env);
+        Mma_gnssUpdate(env, &indicationState);
+//
+        LoggerTraceStatic(LOGGER, LOG_SIGN, "Начало итерации главного цикла")
+        LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем нужна ли сеть...")
+        if (EraGlonassUveos_IsRequireNetwork(&env->uveos)) {
+            LoggerTraceStatic(LOGGER, LOG_SIGN, "Нужна, подключаемся")
+            Mma_SetNetworkRegistration(env, true);
+        } else {
+            LoggerTraceStatic(LOGGER, LOG_SIGN, "Ненужна, отключаемся")
+            Mma_SetNetworkRegistration(env, false);
+        }
+
+        LoggerTraceStatic(LOGGER, LOG_SIGN, "Выполняем постоянный тест")
+        if (DeviceTesting_Always(&env->testing)) {
+            indicationState = DEVICE_MODE_FAILURE;
+        };
+
+        LoggerTraceStatic(LOGGER, LOG_SIGN, "Выполняем периодическое тестирование")
+        if (DeviceTesting_Periodical(&env->testing)) {
+            indicationState = DEVICE_MODE_FAILURE;
+            LoggerTraceStatic(LOGGER, LOG_SIGN, "Обновляем статус индикации")
+        };
+
+        Mma_SetMode(env, indicationState);
+
+//        if(env->uveos.timings.lastInMemTransmit < SystemGetMs()){
+//            LoggerInfoStatic(LOGGER, LOG_SIGN, "Периодическая проверка необходимости повторной отправки МНД");
+//            tEraGlonassMsdTableItem *item = NULL;
+//
+//            volatile uint8_t noSendMsdCount =  EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable);
+//            if(noSendMsdCount > 0) {
+//                GsmWithGnss_InvalidateNetworkEnable(&env->gsmWithGnss, 0, true);
+//            }
+////            GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 5000);
+////            EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos);
+//            if ( GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 20000) ) {
+//                LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует");
+//                EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos);
+//            } else {
+//                LoggerInfoStatic(LOGGER, LOG_SIGN, "Периодическая проверка необходимости повторной отправки МНД не выполнена");
+//                LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует");
+//            }
+//            LoggerInfoStatic(LOGGER, LOG_SIGN, "Время периодическая проверки повторной отправки МНД обновлено");
+//            env->uveos.timings.lastInMemTransmit =
+//                    SystemGetMs() + (env->uveos.settings->INT_MEM_TRANSMIT_INTERVAL * 60 * 1000);
+//        }
+        if(env->uveos.timings.lastInMemTransmit < SystemGetMs()){
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Периодическая проверка необходимости повторной отправки МНД");
+
+            noSendMsdCount = EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable);
+            if (noSendMsdCount > 0) {
+                LoggerInfoStatic(LOGGER, LOG_SIGN, "Проверка регистрации в сети");
+                if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 2000)) {
+                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует");
+                    EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos);
+                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС...");
+                    AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
+                    SystemDelayMs(500);
+                    AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
+                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено");
+                } else {
+                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует, попытка регистрации...");
+                    if (GsmWithGnss_NetworkEnableInnaterups(&env->gsmWithGnss, 5,40000) == AT_OK) {
+                        LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть присутствует")
+                        EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos);
+                        LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС...");
+                        AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
+                        SystemDelayMs(500);
+                        AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt);
+                        LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено");
+                    } else {
+                        LoggerInfoStatic(LOGGER, LOG_SIGN,
+                                         "Периодическая проверка необходимости повторной отправки МНД не выполнена");
+                        LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует");
+                    }
+                }
+                LoggerTraceStatic(LOGGER, LOG_SIGN, "Обработка не отправленных МНД выполнена")
+            }
+
+            env->uveos.timings.lastInMemTransmit =
+                    SystemGetMs() + (env->uveos.settings->INT_MEM_TRANSMIT_INTERVAL * 60 * 1000);
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Время периодическая проверки повторной отправки МНД обновлено");
+        }
+
+
+//        LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем экстренное событие")
+//        if (UveosEmergencyEvent_GetNext(&env->crashDetect.emergencyEvents, &emergencyEvent, 0)) {
+//            if(env->storage.nvm.gost.CRASH_SIGNAL_INTERNAL == 1) {
+//                LoggerInfoStatic(LOGGER, LOG_SIGN, "Экстренное событие получено");
+//                Mma_EcallAutomatic(env, emergencyEvent);
+//            }
+//        }
+
+        LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем экстренное событие")
+        if (UveosEmergencyEvent_GetNext(&env->crashDetect.emergencyEvents, &emergencyEvent, 0)) {
+            if(env->storage.nvm.gost.CRASH_SIGNAL_INTERNAL == 1) {
+                Mma_EcallManualKZ(env);
+//                DeviceTesting_EcallKZ1(&env->testing);
+                LoggerInfoStatic(LOGGER, LOG_SIGN, "Экстренное событие получено");
+//                Mma_EcallAutomatic(env, emergencyEvent);
+            }
+        }
+
+        LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем нажатия кнопок")
+        if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
+
+            if(env->kzModeBloc == false) {
+                if (UserInputButtonEventIsBetween(
+                        buttonEvent, UI_BUTTON_EMERGENCY, RAISE, env->storage.nvm.gost.SOS_BUTTON_TIME, 0xFFFF
+                )) {
+                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Нажата кнопка экстренного вызова KZ 1")
+                    uint32_t tmt = SystemGetMs() + 10000;
+                    UserButtons_Clear(&env->userInput.buttonsInterface);
+                    while (tmt > SystemGetMs()) {
+                        if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
+                            if (UserInputButtonEventIsBetween(
+                                    buttonEvent, UI_BUTTON_EMERGENCY, RAISE, env->storage.nvm.gost.SOS_BUTTON_TIME,
+                                    0xFFFF
+                            )) {
+                                LoggerInfoStatic(LOGGER, LOG_SIGN, "Нажата кнопка экстренного вызова KZ 2")
+                                EraGlonassUveos_SetTimings(&env->uveos);
+                                Mma_SetMode(env, DEVICE_MODE_UVEOS_CALL_INITIATE);
+                                Mma_NetworkAndAudioRequireKz(env);
+                                GpioPinEnable(&env->power.pins->main.ecall);
+                                env->uveos.currentMsd->msd.MSD_Data.msgId = 1;
+
+                                DeviceTesting_EcallKZ(&env->testing);
+//                                Mma_EcallManualKZ(env);
+                                env->kzModeBloc = true;
+                                AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 0);
+                                SystemDelayMs(500);
+                                AtGsmTelitLe910_Gnss_ReStartReceiver(&env->gsmWithGnss.gsmAt, 1);
+
+                                Mma_NetworkAndAudioRelease(env);
+                            }
+                        }
+                        SystemDelayMs(10);
+                    }
+                    if(env->kzModeBloc == false) {
+                        LoggerInfoStatic(LOGGER, LOG_SIGN, "Нажата кнопка экстренного вызова_1")
+                        Mma_EcallManual(env);
+                    }
+                    UserButtons_Clear(&env->userInput.buttonsInterface);
+                }
+            } else
+
+            if (UserInputButtonEventIsBetween(
+                    buttonEvent, UI_BUTTON_EMERGENCY, RAISE, env->storage.nvm.gost.SOS_BUTTON_TIME, 0xFFFF
+            )) {
+                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Нажата кнопка экстренного вызова_2")
+                    Mma_EcallManual(env);
+            } else
+
+            if (UserInputButtonEventIsBetween(buttonEvent, UI_BUTTON_ADDITIONAL, RAISE, 3000, 10000)) {
+                vAsciiStringInit(step, &str_len, 5);
+                vAsciiStringAddDecimalInt64(step, &str_len, env->uveos.doNothing.movDist, 5);
+
+                if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_DISABLED) {
+                    Mma_SetMode(env, DEVICE_MODE_TESTING);
+                    LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим пользовательского тестирования, отклонение дистанции = ");
+                    LoggerInfo(LOGGER, LOG_SIGN, step, str_len);
+                    Mma_UserTestMode(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 не достоверны!");
+                }
+
+            } else if (UserInputButtonEventIsBetween(buttonEvent, UI_BUTTON_ADDITIONAL, RAISE, 10000, 30000)) {
+                vAsciiStringInit(step, &str_len, 5);
+                vAsciiStringAddDecimalInt64(step, &str_len, env->uveos.doNothing.movDist, 5);
+                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 не достоверны!");
+                }
+            }
+
+        }
+
+        if (EraGlonassUveos_IsAllowInCall(&env->uveos) && GsmWithGnss_IsRing(&env->gsmWithGnss)) {
+            Mma_ProcessCallAnswer(env);
+        }
+
+        if (env->storage.runtime.EGTS_FLEET_ON == false) {
+            Mma_CheckIncomingSms(env);
+        }
+
+        Mma_CheckShutdown(env, false);
+        SystemDelayMs(10);
+    }
+}
+
+
+
+void Mma_StartTestThreadStart(tMma *env) {
+    if ( !env->threadTesting.id ) {
+        env->threadTesting.id = osThreadNew(
+                (osThreadFunc_t) (Mma_TestingThread),
+                (void *) (env),
+                &env->threadTesting.attr
+        );
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Сопроводительный поток запущен")
+    }
+}
+
+void Mma_StopTestThreadStart(tMma *env) {
+    if(env->threadTesting.id != NULL) {
+        if (osThreadTerminate(env->threadTesting.id) == osOK) {
+            SystemDelayMs(100);
+            env->threadTesting.id = NULL;
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Сопроводительный поток остановлен")
+            SystemDelayMs(500);
+        }
+    }
+}
+
+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);
+    }
+}
diff --git a/MainModesArbiter.h b/MainModesArbiter.h
new file mode 100644
index 0000000..c2f668c
--- /dev/null
+++ b/MainModesArbiter.h
@@ -0,0 +1,106 @@
+//
+// Created by xemon on 19.09.22.
+//
+
+#ifndef UVEOS_ON_NATION_MMA_H
+#define UVEOS_ON_NATION_MMA_H
+
+//Железные интерфесы
+#include "PeripheralInterfaces.h"
+#include "DevRtc.h"
+#include "RtcIO.h"
+#include "EgtsProcessing.h"
+//Переферийные устройства
+#include <DeviceStorage.h>
+#include <AudioCodec.h>
+#include <Accel.h>
+
+#if USE_GSM_AND_GNSS_TELIT
+
+#include <GsmWithGnss.h>
+
+#endif
+
+#ifdef USE_GSM_AND_GNSS_SIMCOM
+
+#include <Gsm.h>
+#include <Gnss.h>
+
+#endif
+
+
+//Подсистемы
+#include <PowerManagement.h>
+#include <LoggerToSerialPort.h>
+#include <ComInt.h>
+#include <ComandLineInterface.h>
+#include <DeviceTesting.h>
+#include <CrashDetection.h>
+#include <EraGlonassUveos.h>
+
+typedef struct {
+
+    // Преферийные интерфесы
+    tGpios *gpios;
+    tSerialPorts *serialPorts;
+    tI2cPorts *i2cPorts;
+    tSpiPorts *spiPorts;
+    tAdcs *adcs;
+    tStorageOnFlash *flash;
+    tRtc *rtc;
+
+    // Преферийные устройства
+    tDeviceStorage storage;
+    tPowerManagement power;
+    tAudioCodec audioCodec;
+    tGsmWithGnss gsmWithGnss;
+    tAccel accel;
+
+    //Подсистемы
+    tLoggerToSerialPort slog;
+
+    tUserInput userInput;
+    tUserIndication indication;
+    tComInt comInt;
+//    tCli cli;
+//    tCli cliVrt;
+
+    tDeviceTesting testing;
+
+    tCrashDetection crashDetect;
+    tEraGlonassUveos uveos;
+
+    uint32_t lastSmsCheckTime;
+
+    struct {
+        osThreadId_t id;
+        uint32_t stack[4048]; //4048 6072
+        StaticTask_t controlBlock;
+        osThreadAttr_t attr;
+    } thread;
+
+
+    tStaticThreadBlock(512) threadTesting;
+    bool flIgn;
+    volatile bool kzModeBloc;
+  //  tSignPack signature;
+
+    tEgtsProcessing egtsProcessing;
+} tMma;
+
+void Mma_Init(
+        tMma *env,
+        tGpios *gpios,
+        tSerialPorts *serialPorts,
+        tI2cPorts *i2cPorts,
+        tSpiPorts *spiPorts,
+        tAdcs *adcs,
+        tStorageOnFlash *flash,
+        tRtc *rtc
+);
+
+void Mma_StartThread(tMma *env);
+
+#define Mma_SetMode(ENV, VALUE) UserIndication_SetMode(&((ENV)->indication),(VALUE))
+
+#endif //UVEOS_ON_NATION_MMA_H
diff --git a/MainModesArbiter_EgtsSms.c b/MainModesArbiter_EgtsSms.c
new file mode 100644
index 0000000..84d89ec
--- /dev/null
+++ b/MainModesArbiter_EgtsSms.c
@@ -0,0 +1,33 @@
+//
+// Created by xemon on 09.01.23.
+//
+
+#include "MainModesArbiter_Private.h"
+#include <AtGsmSms_Utils.h>
+
+#define LOG_SIGN "Главн. sms"
+#define LOGGER &env->slog.logger
+
+void Mma_CheckIncomingSms(tMma *env) {
+
+    if ((env->lastSmsCheckTime + 3000) > SystemGetMs()) {
+        return;
+    }
+    env->lastSmsCheckTime = SystemGetMs();
+
+    uint8_t binaryData[255];
+    memset(binaryData, 0, sizeof(binaryData));
+    uint16_t binaryDataSize;
+
+    if (AtGsmSms_UtilsReadPduData(&env->gsmWithGnss.gsmAt, binaryData, &binaryDataSize, sizeof(binaryData)) == AT_OK) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена команда посредствам СМС");
+        if (binaryDataSize) {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Команда содержит EGTS пакет");
+            Mma_NetworkAndAudioRequire(env);
+            EraGlonassUveos_ProcessEgtsPacket(&env->uveos, binaryData, binaryDataSize);
+        } else {
+            LoggerInfoStatic(LOGGER, LOG_SIGN, "Команда не содержит EGTS пакета");
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/MainModesArbiter_InitStage.c b/MainModesArbiter_InitStage.c
new file mode 100644
index 0000000..7cca378
--- /dev/null
+++ b/MainModesArbiter_InitStage.c
@@ -0,0 +1,508 @@
+//
+// Created by xemon on 11.12.22.
+//
+
+#include "MainModesArbiter_Private.h"
+#include "FirmwareMetadataSection.h"
+
+#define LOG_SIGN "Главн. Вкл"
+#define LOGGER &env->slog.logger
+
+static void Mma_InitSubSystems(tMma *env);
+
+static void Mma_InitAndRunIndication(tMma *env);
+
+static void Mma_InitPower(tMma *env);
+
+static void Mma_InitComInt(
+        tMma *env,
+        tString16 *deviceId,
+        tVariablesTable *varsTab
+) {
+    tSerialPortIO *thisComIntPortIO;
+
+    if(GpioPinGet(&env->power.pins->usb)){
+        thisComIntPortIO = &env->serialPorts->SerialPortUsbIO;
+    } else {
+        thisComIntPortIO = &env->serialPorts->ComIntHalfDuplexIo;
+    }
+//    thisComIntPortIO = &env->serialPorts->SerialPortCan2IO;
+    ComInt_Init(
+            &env->comInt,
+            thisComIntPortIO,
+            deviceId,
+            varsTab,
+            &env->testing.testsTable,
+#ifdef USE_GSM_AND_GNSS_TELIT
+            &env->serialPorts->TelitIOSniffer,
+            &env->serialPorts->cliVirtualOutIo,
+            NULL,
+#endif
+#ifdef USE_GSM_AND_GNSS_SIMCOM
+            &env->serialPorts->Sim7600IOSniffer,
+            &env->serialPorts->cliVirtualOutIo,
+            &env->serialPorts->Sim68Sniffer,
+#endif
+            &env->indication.currentModeName,
+            &env->crashDetect.carCrashDetection.flip
+    );
+}
+
+void Mma_GetHardVers(tMma *env) {
+    tVariableDescriptor *var = VariablesTable_GetByNameStatic(&env->storage.publicVariablesTable, "HARDWARE_VERS");
+
+    if (var->len) {
+        tStringLink hardVersValue = {
+                .length = var->len,
+                .data = var->addr
+        };
+
+        if (!*hardVersValue.length) {
+            env->storage.nvm.device.hardVers.length = META_HW_NAME_SIZE;
+            memcpy(env->storage.nvm.device.hardVers.data, (char *) META_HW_NAME, META_HW_NAME_SIZE);
+            SystemDelayMs(200);
+        }
+    }
+}
+
+void Mma_GetSoftVers(tMma *env) {
+    tVariableDescriptor *var = VariablesTable_GetByNameStatic(&env->storage.publicVariablesTable, "SOFTWARE_VERS");
+
+    if (var->len) {
+        tStringLink softVersValue = {
+                .length = var->len,
+                .data = var->addr
+        };
+
+        if (!*softVersValue.length) {
+            env->storage.nvm.device.softVers.length = META_FW_NAME_SIZE;
+            memcpy(env->storage.nvm.device.softVers.data, (char *) META_FW_NAME, META_FW_NAME_SIZE);
+            SystemDelayMs(200);
+        }
+    }
+}
+
+void Mma_GetCCID(tMma *env) {
+    tVariableDescriptor *var = VariablesTable_GetByNameStatic(&env->storage.publicVariablesTable, "GSM_CCID");
+
+    if (var->len) {
+
+        tStringLink ccidValue = {
+                .length = var->len,
+                .data = var->addr
+        };
+
+        if (!*ccidValue.length) {
+            size_t length;
+            AtCommandResult resGetCCID;
+            resGetCCID = GsmWithGnss_GetCCID(&env->gsmWithGnss.gsmAt, ccidValue.data, &length);
+
+            SystemDelayMs(200);
+            if (resGetCCID == AT_OK) {
+                *ccidValue.length = length;
+                DeviceStorage_ForceDump(&env->storage);
+                SystemDelayMs(200);
+            }
+        }
+
+    }
+}
+
+
+void Mma_GetCGSN(tMma *env) {
+    tVariableDescriptor *var = VariablesTable_GetByNameStatic(&env->storage.publicVariablesTable, "GSM_CGSN");
+
+    tStringLink cgsmidValue = {
+            .length = var->len,
+            .data = var->addr
+    };
+
+    if (var->len) {
+
+        if (!*cgsmidValue.length) {
+            size_t length;
+            AtCommandResult resGetCGSN;
+            resGetCGSN = GsmWithGnss_GetCGSN(&env->gsmWithGnss.gsmAt, cgsmidValue.data, &length);
+            bool b = 0;
+            if (resGetCGSN == AT_OK) {
+                b = true;
+            }
+            if (b) {
+                *cgsmidValue.length = length;
+                DeviceStorage_ForceDump(&env->storage);
+                SystemDelayMs(200);
+                return;
+            }
+        }
+
+    }
+}
+
+_Noreturn void Mma_FatalErrorOnInit(tMma *env, bool noinit, eDeviceModes errState) {
+
+    tString16 alertId;
+
+    if (noinit) {
+        Mma_InitPower(env);
+        Mma_InitAndRunIndication(env);
+        String16CopyStatic(&alertId, "MEMERR");
+        Mma_InitComInt(env, &alertId, NULL);
+        ComInt_StartThread(&env->comInt);
+    }
+
+    Mma_SetMode(env, errState);
+
+    for (;;) {
+        Mma_CheckShutdown(env, true);
+        SystemDelayMs(1000);
+    }
+}
+
+static void Mma_InitPeripheralDevices(tMma *env) {
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация устройств...")
+    GsmWithGnssInit(
+            &env->gsmWithGnss,
+            &env->serialPorts->TelitIO,
+            &env->storage.nvm.device.smsServiceCenter,
+            &env->storage.nvm.gost.GNSS_DATA_RATE,
+            &env->rtc->rtcIo,
+            &env->storage.runtime.enableGnssUpdate,
+            false
+    );
+    env->gsmWithGnss.logger = &env->slog.logger;
+    env->gsmWithGnss.ecallProvider.smsEnv = env;
+    env->gsmWithGnss.ecallProvider.checkSms = (void *) Mma_CheckIncomingSms;
+    env->gsmWithGnss.ecallProvider.isNetworkState = (void *) GsmWithGnss_WaitNetworkRegistration;
+    env->gsmWithGnss.ecallProvider.isNetworkReg = (void *) GsmWithGnss_InvalidateNetworkEnable;
+
+    env->gsmWithGnss.ecallProvider.ShutdownEnv = env;
+    env->gsmWithGnss.ecallProvider.CheckShutdown = (void *) Mma_CheckShutdownIsBattary;
+
+
+    AudioCodecInit(&env->audioCodec, &env->i2cPorts->max9860Io, &env->storage.nvm.audioCodec);
+    Accel_Init(&env->accel, &env->spiPorts->accelIO);
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация устройств завершена")
+}
+
+void Mma_StartupAudioSubsystem(tMma *env) {
+    Pwm_AudioEnable(&env->power);
+
+    while (!AudioCodecEnable(&env->audioCodec)) {
+        Mma_SetMode(env, DEVICE_MODE_ERROR_CODEC);
+    }
+}
+
+static void Mma_StartupDevices(tMma *env) {
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск устройств...")
+    Accel_StartDevice(&env->accel);
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск устройств завершен")
+}
+
+static void Mma_InitSubSystems(tMma *env) {
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация подсистем...")
+
+    CrashDetection_Init(
+            &env->crashDetect,
+            &env->accel.accelDataFlow,
+            &env->storage.nvm.gost.ASI15_TRESHOLD,
+            &env->storage.nvm.flip,
+            &env->slog.logger
+    );
+
+    EraGlonassUveos_Init(
+            &env->uveos,
+            &env->slog.logger,
+            &env->storage.nvm.msdTable,
+            &env->storage.nvm.gost,
+            &env->storage.uveosDumper,
+
+            &env->gsmWithGnss.navDataProvider,
+            &env->gsmWithGnss.ecallProvider,
+            &env->gsmWithGnss.smsProvider,
+
+            &env->indication.uveosIndicator,
+            &env->userInput.buttonsInterface,
+            UI_BUTTON_ADDITIONAL,
+
+            &env->gsmWithGnss.audioPlayer,
+            &env->rtc->rtcIo,
+            0
+    );
+
+    UserInput_Init(
+            &env->userInput,
+            &env->gpios->bip.buttons
+    );
+
+    DeviceTesting_Init(
+            &env->testing,
+
+            &env->userInput.watcher,
+            &env->gpios->power.main.ignition,
+            &env->adcs->gnssAntennaIo,
+            &env->adcs->speakerIo,
+            &env->adcs->batteryIo,
+            &env->accel,
+
+            &env->gsmWithGnss,
+            &env->audioCodec,
+            &env->slog.logger,
+
+            &env->gsmWithGnss.gsmAt,
+            &env->gsmWithGnss.audioPlayer,
+            &env->gsmWithGnss.audioRecorder,
+
+            &env->userInput.buttonsInterface,
+            &env->indication,
+            &env->uveos,
+            &env->storage.nvm.device.useInternalAnt,
+            &env->power.pins->telit.ring
+    );
+/*
+    Cli_Init(
+            &env->cliVrt,
+            &env->serialPorts->cliVirtualInIo,
+//            NULL,
+            &env->serialPorts->TelitIOSniffer,
+
+            &env->storage.publicVariablesTable,
+            &env->crashDetect.carCrashDetection.flip,
+            &env->storage.nvm.msdTable,
+            &env->crashDetect.simulationInterface,
+            &env->userInput.watcher,
+            env->uveos.dumper,
+            &env->power, &env->gsmWithGnss,
+            &env->uveos
+    );
+
+    Cli_Init(
+            &env->cli,
+            &env->serialPorts->DebugIO,
+
+            &env->serialPorts->TelitIOSniffer,
+
+            &env->storage.publicVariablesTable,
+            &env->crashDetect.carCrashDetection.flip,
+            &env->storage.nvm.msdTable,
+            &env->crashDetect.simulationInterface,
+            &env->userInput.watcher,
+            env->uveos.dumper,
+            &env->power,
+            &env->gsmWithGnss,
+            &env->uveos
+    );
+*/
+    Mma_InitComInt(env, &env->storage.nvm.device.serialNumber.value, &env->storage.publicVariablesTable);
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация подсистем завершена")
+}
+
+static void Mma_RunSubThreads(tMma *env) {
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск субпотоков...")
+
+    VarsTabDumpObserver_StartThread(&env->storage.dumpObserver);
+    Accel_StartThread(&env->accel);
+    CrashDetection_StartThread(&env->crashDetect);
+/*
+    Cli_StartThread(&env->cli);
+    Cli_StartThread(&env->cliVrt);
+    */
+    UserInput_StartThread(&env->userInput);
+
+    ComInt_StartThread(&env->comInt);
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Субпотоки запущены")
+}
+
+static void Mma_InitPower(tMma *env) {
+    Pwm_Init(&env->power, &env->gpios->power, &env->adcs->batteryIo, &env->storage.nvm.device.useMutePositive);
+    Pwm_OnDeviceInit(&env->power);
+    PowerManagement_StartThread(&env->power);
+}
+
+void Mma_InitBipPower(tMma *env) {
+#if USE_POLAR_DEPENDENT_BIP
+    GpioPinSet(&env->gpios->bip.powerBip.ignitionOn, false);
+    SystemDelayMs(10);
+    GpioPinSet(&env->gpios->bip.powerBip.bacLightOn, true);
+    if (env->uveos.settings->notGost.BIP_BACKLIGHT_MODE == 1) {
+        GpioPinSet(&env->gpios->bip.powerBip.bacLightOn, true);
+        SystemDelayMs(10);
+        GpioPinSet(&env->gpios->bip.powerBip.ignitionOn, true);
+
+    } else  if (env->uveos.settings->notGost.BIP_BACKLIGHT_MODE == 2) {
+        GpioPinSet(&env->gpios->bip.powerBip.ignitionOn, false);
+        SystemDelayMs(10);
+        GpioPinSet(&env->gpios->bip.powerBip.bacLightOn, false);
+
+    } else  if (env->uveos.settings->notGost.BIP_BACKLIGHT_MODE == 0) {
+        GpioPinSet(&env->gpios->bip.powerBip.ignitionOn, false);
+        SystemDelayMs(10);
+        GpioPinSet(&env->gpios->bip.powerBip.bacLightOn, true);
+    }
+#endif
+}
+
+static void Mma_InitLogger(tMma *env) {
+    LoggerToSerialPort_Init(
+            &env->slog,
+            0,
+            &env->serialPorts->cliVirtualInIo,
+            &env->rtc->rtcIo,
+//            NULL,
+            SERIAL_LOGGER_SHOW_AUTHOR | SERIAL_LOGGER_SHOW_LOG_LEVEL |
+            SERIAL_LOGGER_SHOW_TIME// | SERIAL_LOGGER_SHOW_TIME
+    );
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Начало логирования")
+    env->storage.logger = &env->slog.logger;
+    env->power.logger = &env->slog.logger;
+    env->storage.dumpObserver.logger = &env->slog.logger;
+}
+
+
+static void Mma_InitAndRunIndication(tMma *env) {
+    UserIndication_Init(&env->indication,
+                        DEVICE_MODE_STARTUP,
+#if USE_POLAR_DEPENDENT_BIP
+                        &env->gpios->bip.uiLeds,
+#else
+                         &env->gpios->bip.led,
+#endif
+                        &env->gpios->onBoardLed,
+#ifdef USE_GSM_AND_GNSS_TELIT
+                        &env->gsmWithGnss.audioPlayer
+#else
+            NULL
+#endif
+    );
+
+    UserIndication_StartThread(&env->indication);
+}
+
+
+void Mma_ColorBip(tMma *env) {
+    if (!GpioPinGet(&env->power.pins->main.ignition)) {
+        env->flIgn = false;
+    } else  if ((GpioPinGet(&env->power.pins->main.ignition)) && (env->flIgn == false)) {
+        eDeviceModes tmpSate = env->indication.mode;
+        Mma_SetMode(env, DEVICE_MODE_UVEOS_IGN_ON);
+
+        uint32_t time = SystemGetMs() + 6000;
+        while (time > SystemGetMs()) {
+            GpioPinSet(&env->gpios->onBoardLed.red, true);
+            #if USE_POLAR_DEPENDENT_BIP
+            if(env->gpios->bip.uiLeds.red.mode == 0){
+                /// red off
+                GpioPinSet(&env->gpios->bip.uiLeds.red.negativ, false);
+                GpioPinSet(&env->gpios->bip.uiLeds.red.positiv, true);
+            } else if(env->gpios->bip.uiLeds.red.mode == 1) {
+                /// green off
+                GpioPinSet(&env->gpios->bip.uiLeds.red.negativ, false);
+                GpioPinSet(&env->gpios->bip.uiLeds.red.positiv, true);
+                /// red on
+                GpioPinSet(&env->gpios->bip.uiLeds.red.negativ, true);
+                GpioPinSet(&env->gpios->bip.uiLeds.red.positiv, false);
+            }
+            #else
+                GpioPinSet(&env->gpios->bip.led.red, true);
+            #endif
+            SystemDelayMs(1);
+        }
+        GpioPinSet(&env->gpios->onBoardLed.red, false);
+        env->flIgn = true;
+        Mma_SetMode(env, tmpSate);
+    }
+}
+
+void Mma_InitStage(tMma *env) {
+    Mma_InitPower(env);
+
+    Mma_InitLogger(env);
+
+    if (!DeviceStorage_Init(&env->storage, &env->flash->interface)) {
+        Mma_FatalErrorOnInit(env, true, DEVICE_MODE_ERROR_FLASH);
+    }
+
+    Mma_InitAndRunIndication(env);
+
+    Mma_SetMode(env, DEVICE_MODE_STARTUP);
+
+    Mma_InitPeripheralDevices(env);
+    Mma_StartupDevices(env);
+    Mma_InitSubSystems(env);
+    Mma_InitBipPower(env);
+#if USE_POLAR_DEPENDENT_BIP
+    env->indication.uiuLed->green.mode = env->uveos.settings->notGost.BIP_GREEN_LED_POWER_MODE;
+    env->indication.uiuLed->red.mode = env->uveos.settings->notGost.BIP_RED_LED_POWER_MODE;
+#endif
+    Mma_RunSubThreads(env);
+
+    if (GpioPinGet(&env->power.pins->main.ignition)) {
+        Mma_ColorBip(env);
+//        Mma_SetMode(env, DEVICE_MODE_UVEOS_IGN_ON);
+        env->flIgn = true;
+    }
+
+    LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Ждем первые данные от акселерометра...")
+    if (Accel_WaitReady(&env->accel, 1000)) {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "получены")
+    } else {
+        LoggerInfoStatic(LOGGER, LOG_SIGN, "пока что нет")
+    }
+
+    if (DeviceTesting_OnIgnitionWithoutGsm(&env->testing)) {
+        LoggerErrorStatic(LOGGER, LOG_SIGN, "Ошибка начального тестирования")
+        Mma_FatalErrorOnInit(env, false, DEVICE_MODE_ERROR_ON_INIT_TEST1);
+    }
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Начальное тестирование ч.1 пройдено")
+
+    Mma_GetHardVers(env);
+    Mma_GetSoftVers(env);
+
+    Mma_SetMode(env, DEVICE_MODE_WAIT_GSM_BOOT);
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Ждем загрузку GSM...")
+
+    if(env->storage.nvm.device.useInternalAnt == true) {
+        GpioPinEnable(&env->power.pins->main.inAnt);
+    } else {
+        GpioPinDisable(&env->power.pins->main.inAnt);
+    }
+
+    while (!GsmWithGnssWaitStartup(&env->gsmWithGnss)) {
+        Mma_SetMode(env, DEVICE_MODE_ERROR_GSM);
+    }
+    Gsm_WaitGsmBoot(&env->gsmWithGnss);
+    Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY);
+
+    Mma_GetCCID(env);
+    Mma_GetCGSN(env);
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализируем звуковую подсистему(кодек,усилитель)")
+    Mma_StartupAudioSubsystem(env);
+
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновляем настроку антены")
+
+#ifdef USE_GSM_AND_GNSS_TELIT
+//    GsmWithGnss_UseInternalAntenna(&env->gsmWithGnss, env->storage.nvm.device.useInternalAnt);
+#endif
+
+#ifdef USE_GSM_AND_GNSS_SIMCOM
+    //        Gsm_UseInternalAntenna(&env->gsm, env->storage.nvm.device.useInternalAnt);
+#endif
+
+    Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_WAIT_GNSS);
+    if (DeviceTesting_OnIgnitionAfterGsm(&env->testing)) {
+        Mma_FatalErrorOnInit(env, false, DEVICE_MODE_ERROR_ON_INIT_TEST2);
+        LoggerErrorStatic(LOGGER, LOG_SIGN, "Ошибка начального тестирования!!!")
+    }
+    LoggerInfoStatic(LOGGER, LOG_SIGN, "Начальное тестирование ч.2 пройдено")
+
+//    String32CopyStatic(&env->storage.nvm.device.codecConf, "00109000040033060f20320000008a");
+    if(env->storage.nvm.device.codecConf.length != 0) {
+        GsmWithGnss_setCodecConf(&env->gsmWithGnss.gsmAt, env->storage.nvm.device.codecConf);
+    }
+
+}
\ No newline at end of file
diff --git a/MainModesArbiter_Private.h b/MainModesArbiter_Private.h
new file mode 100644
index 0000000..2d2d12f
--- /dev/null
+++ b/MainModesArbiter_Private.h
@@ -0,0 +1,49 @@
+//
+// Created by xemon on 11.12.22.
+//
+
+#ifndef UVEOS_ON_NATION_MAINMODESARBITER_PRIVATE_H
+#define UVEOS_ON_NATION_MAINMODESARBITER_PRIVATE_H
+
+#include "MainModesArbiter.h"
+
+
+#define Mma_SetMode(ENV, VALUE) UserIndication_SetMode(&((ENV)->indication),(VALUE))
+
+void Mma_ColorBip(tMma *env);
+
+void Mma_FatalErrorOnInit(tMma *env, bool noinit, eDeviceModes errState);
+
+void Mma_StartupAudioSubsystem(tMma *env);
+
+void Mma_StartTestThreadStart(tMma *env);
+
+void Mma_InitStage(tMma *env);
+
+void Mma_CheckShutdown(tMma *env, bool fastBlackOut) ;
+
+void Mma_CheckShutdownIsBattary(tMma *env);
+
+void Mma_CheckIncomingSms(tMma *env);
+
+void Mma_NetworkAndAudioRequire(tMma *env);
+
+void Mma_EcallManual(tMma *env);
+
+void Mma_EcallAutomatic(tMma *env, tUveosEmergencyEvent emergencyEvent);
+
+void Mma_GetHardVers(tMma *env);
+
+void Mma_GetSoftVers(tMma *env);
+
+void Mma_GetCCID(tMma *env);
+
+void Mma_GetCGSN(tMma *env);
+
+void Mma_InitBipPower(tMma *env);
+
+//bool Mma_GetNewSms(tMma *env, uint8_t *binaryData, uint16_t size, uint16_t *binaryDataSize);
+//
+//void Mma_SmsProcrssing(tMma *env, uint8_t *binaryData, const uint16_t *binaryDataSize);
+
+#endif //UVEOS_ON_NATION_MAINMODESARBITER_PRIVATE_H
diff --git a/PeripheralInterfaces.c b/PeripheralInterfaces.c
new file mode 100644
index 0000000..e2be3bd
--- /dev/null
+++ b/PeripheralInterfaces.c
@@ -0,0 +1,17 @@
+//
+// Created by xemon on 11.12.22.
+//
+#include "PeripheralInterfaces.h"
+#include "DevRtc.h"
+//#include "main2.h"
+
+void InitPeripheralInterfaces() {
+    Gpios_Init();
+    Adcs_Init();
+    SerialPorts_Init(&GPIOS.comIntDir);
+    I2cPorts_Init();
+    SpiPorts_Init(&GPIOS.accel, &GPIOS.flash);
+    StorageOnFlash_Init();
+//    mainUsb();
+    Rtc_Init();
+}
\ No newline at end of file
diff --git a/PeripheralInterfaces.h b/PeripheralInterfaces.h
new file mode 100644
index 0000000..2171249
--- /dev/null
+++ b/PeripheralInterfaces.h
@@ -0,0 +1,17 @@
+//
+// Created by xemon on 11.12.22.
+//
+
+#ifndef UVEOS_ON_NATION_DEVICE_PERIPHERALINTERFACES_H
+#define UVEOS_ON_NATION_DEVICE_PERIPHERALINTERFACES_H
+
+#include <Gpios.h>
+#include <Adcs.h>
+#include <SerialPorts.h>
+#include <I2cPorts.h>
+#include <SpiPorts.h>
+#include <StorageOnFlash.h>
+
+void InitPeripheralInterfaces();
+
+#endif //UVEOS_ON_NATION_DEVICE_PERIPHERALINTERFACES_H
diff --git a/modular.json b/modular.json
new file mode 100644
index 0000000..0450734
--- /dev/null
+++ b/modular.json
@@ -0,0 +1,57 @@
+{
+  "dep": [
+    {
+      "type": "git",
+      "provider": "NAVIGATOR_UVEOS_NATION_TELIT",
+      "repo": "UveosGostSettings"
+    },
+    {
+      "type": "git",
+      "provider": "NAVIGATOR_UVEOS_NATION_TELIT",
+      "repo": "UveosOnNation_VEGA_AudioCodec"
+    },
+    {
+      "type": "git",
+      "provider": "NAVIGATOR_UVEOS_NATION_TELIT",
+      "repo": "LoggerInterface"
+    },
+    {
+      "type": "git",
+      "provider": "NAVIGATOR_UVEOS_NATION_TELIT",
+      "repo": "LoggerToSerialPort"
+    },
+    {
+      "type": "git",
+      "provider": "NAVIGATOR_UVEOS_NATION_TELIT",
+      "repo": "AudioPlayerTelitLe910"
+    },
+    {
+      "type": "git",
+      "provider": "NAVIGATOR_UVEOS_NATION_TELIT",
+      "repo": "UveosOnNation_VEGA_CrashDetection"
+    },
+    {
+      "type": "git",
+      "provider": "NAVIGATOR_UVEOS_NATION_TELIT",
+      "repo": "UveosOnNation_VEGA_GpioPins"
+    },
+    {
+      "type": "git",
+      "provider": "NAVIGATOR_UVEOS_NATION_TELIT",
+      "repo": "UveosOnNation_VEGA_Accel"
+    },
+    {
+      "type": "git",
+      "provider": "NAVIGATOR_UVEOS_NATION_TELIT",
+      "repo": "BootJump_NATION_N32G45X"
+    }
+  ],
+  "cmake": {
+    "inc_dirs": [
+      "./"
+    ],
+    "srcs": [
+      "./**.c"
+    ]
+  }
+}
\ No newline at end of file