NAVIGATOR_UVEOS_NATION_TELIT
/
UveosOnNation_VEGA_MainModesArbiter
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Init

This commit is contained in:
cfif 2024-12-04 13:10:47 +03:00
commit af875d4875
8 changed files with 1474 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

687
MainModesArbiter.c Normal file
View File

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

106
MainModesArbiter.h Normal file
View File

@ -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

33
MainModesArbiter_EgtsSms.c Normal file
View File

@ -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 пакета");
}
}
}

508
MainModesArbiter_InitStage.c Normal file
View File

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

49
MainModesArbiter_Private.h Normal file
View File

@ -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

17
PeripheralInterfaces.c Normal file
View File

@ -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();
}

17
PeripheralInterfaces.h Normal file
View File

@ -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

57
modular.json Normal file
View File

@ -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"
]
}
}