From 6a9b5825093d1ab19bd5f21fb0a5929139a6eb82 Mon Sep 17 00:00:00 2001 From: cfif Date: Mon, 2 Jun 2025 13:26:39 +0300 Subject: [PATCH] Init --- InfoSystemToUDS.c | 444 +++++++++ MainModesArbiter.c | 1633 ++++++++++++++++++++++++++++++++++ MainModesArbiter.h | 188 ++++ MainModesArbiter_Ecalls.c | 239 +++++ MainModesArbiter_EgtsSms.c | 76 ++ MainModesArbiter_InitStage.c | 1143 ++++++++++++++++++++++++ MainModesArbiter_Private.h | 122 +++ PeripheralInterfaces.c | 16 + PeripheralInterfaces.h | 18 + TelematicaConnectStatus.h | 15 + modular.json | 10 + 11 files changed, 3904 insertions(+) create mode 100644 InfoSystemToUDS.c create mode 100644 MainModesArbiter.c create mode 100644 MainModesArbiter.h create mode 100644 MainModesArbiter_Ecalls.c create mode 100644 MainModesArbiter_EgtsSms.c create mode 100644 MainModesArbiter_InitStage.c create mode 100644 MainModesArbiter_Private.h create mode 100644 PeripheralInterfaces.c create mode 100644 PeripheralInterfaces.h create mode 100644 TelematicaConnectStatus.h create mode 100644 modular.json diff --git a/InfoSystemToUDS.c b/InfoSystemToUDS.c new file mode 100644 index 0000000..362f334 --- /dev/null +++ b/InfoSystemToUDS.c @@ -0,0 +1,444 @@ +// +// Created by zemon on 21.08.24. +// + +#include +#include "MainModesArbiter_Private.h" +#include "DeviceTesting_TestingMethods.h" +#include "DeviceTesting.h" + +#define LOG_SIGN "Главн состояние в UDS." +#define LOGGER &env->slog.logger +eDeviceTestingCode resBatState; +crm_clocks_freq_type crm_clocks_freq_structure = {0}; + +void Mma_InfoSystemToUDSGetModemState(tModemDataColl *ModemDataCollector, const tDeviceModes *deviceModes, tSystemStateID_0006 *state) { + switch (*deviceModes) { + case DEVICE_MODE_UVEOS_MSD_TRANSMIT: + state->GSM_State = MSD_SENDS; + break; + case DEVICE_MODE_UVEOS_IN_CALL: + state->GSM_State = INCOMING_CALL; + break; + case DEVICE_MODE_UVEOS_SYSTEM_STARTUP: + state->GSM_State = INITIALIZING; + break; + case DEVICE_MODE_TESTING: + state->GSM_State = IDLE; + break; + case DEVICE_MODE_UVEOS_ERA_GNSS_READY: + state->GSM_State = IDLE; + break; + case DEVICE_MODE_UVEOS_ERA_WAIT_GNSS: + state->GSM_State = IDLE; + break; + default: + state->GSM_State = INITIALIZING; + break; + } +} + +void Mma_InfoSystemToUDSGetMotionState(tPowerManagement *env, tSystemStateID_0006 *state) { + if (GpioPinGet(&env->powerSusystem->main.ignition)) { + state->Motion_State = 1; + } else { + state->Motion_State = 0; + } +} + +void Mma_InfoSystemToUDSGetBattaryState(tPowerManagement *env, tSystemStateID_0006 *state) { + if (osMutexAcquire(env->mux_accessPwrMan, 100) == osOK) { + resBatState = DeviceTesting_AdcBatteryChargeTest(&env->powerSusystem->battery); + osMutexRelease(env->mux_accessPwrMan); + switch (resBatState) { + case DEVICE_TESTING_CODE_ERROR: + state->Battery_State = NO_CHARGE; + break; + case DEVICE_TESTING_CODE_BATTERY_PRE_CHARGE: + state->Battery_State = TRICLE_CHHARGE; + break; + case DEVICE_TESTING_CODE_BATTERY_FAST_CHARGE: + state->Battery_State = FAST_CHARGE; + break; + case DEVICE_TESTING_CODE_BATTERY_CHARGE_DONE: + state->Battery_State = STABILISATION; + break; + default: + state->Battery_State = UNDEFINDET; + break; + } + } +} + +void Mma_InfoSystemToUDSGetInputLinesState(tGpios *gpios, tInputStatesRecord_0001 *env) { + if (GpioPinGet(&gpios->bip.buttons.emergency)) { + env->Input_SOS = STATE_RECORD001_ON; + } else { + env->Input_SOS = STATE_RECORD001_OFF; + } + + if (GpioPinGet(&gpios->bip.buttons.additional)) { + env->Input_Service = STATE_RECORD001_ON; + } else { + env->Input_Service = STATE_RECORD001_OFF; + } + + if (GpioPinGet(&gpios->powerSusystem.main.ignition)) { + env->Input_KL15 = STATE_RECORD001_ON; + } else { + env->Input_KL15 = STATE_RECORD001_OFF; + } +} + +void Mma_InfoSystemToUDSpowerStatus(tGpios *gpios, tPowerManagement *power, tOutputStatesRecord_0002 *env) { + if (GpioPinGet(&power->powerSusystem->sim7600.powerStatus)) { + env->OutputMODEM_ON = STATE_RECORD002_ON; + } else { + env->OutputMODEM_ON = STATE_RECORD002_OFF; + } +} + +void Mma_InfoSystemToUDSGetModemResetState(tGpios *gpios, tPowerManagement *power, tOutputStatesRecord_0002 *env) { + if (GpioPinGet(&power->powerSusystem->sim7600.reset)) { + env->Output_Modem_Reset = STATE_RECORD002_ON; + } else { + env->Output_Modem_Reset = STATE_RECORD002_OFF; + } +} + +void Mma_InfoSystemToUDSGetRedLedState(tGpios *gpios, tOutputStatesRecord_0002 *env) { + + if (GpioPinGet(&gpios->bip.led.red)) { + env->Output_RED_LED = STATE_RECORD002_ON; + } else { + env->Output_RED_LED = STATE_RECORD002_OFF; + } +} + +void Mma_InfoSystemToUDSGetRedGreenState(tGpios *gpios, tOutputStatesRecord_0002 *env) { + if (GpioPinGet(&gpios->bip.led.green)) { + env->Output_GREEN_LED = STATE_RECORD002_ON; + } else { + env->Output_GREEN_LED = STATE_RECORD002_OFF; + } +} + +void Mma_InfoSystemToUDSGetSimProfileAmount(uint8_t *SimProfileAmount) { + *SimProfileAmount = (uint8_t) 1; +} + +void Mma_InfoSystemToUDSGetTCMTimeCalculation(uint8_t *TimeCalculation) { + *TimeCalculation = (uint8_t) 1; +} + +void Mma_InfoSystemToUDSGetBoardVoltage(tPowerManagement *power, uint8_t *BoardVoltage) { + if (osMutexAcquire(power->mux_accessPwrMan, 100) == osOK) { + double BoardVoltageTmp = (double )power->powerSusystem->boardPower.currentBoardVoltage / 1000; + *BoardVoltage = (uint8_t) (BoardVoltageTmp / 0.0942); + osMutexRelease(power->mux_accessPwrMan); + } +} + +void Mma_InfoSystemToUDSGetBatteryCharge(tPowerManagement *power, uint8_t *ReserveBatteryCharge) { + if (osMutexAcquire(power->mux_accessPwrMan, 100) == osOK) { + + uint8_t BatteryCharge; + + if (power->powerSusystem->battery.currentBatVoltage < 3300) { + BatteryCharge = 0; + } else { + + if (power->powerSusystem->battery.currentBatVoltage > 4200) { + BatteryCharge = 100; + } else { + BatteryCharge = ((power->powerSusystem->battery.currentBatVoltage - 3300) * 100) / (4200 - 3300); + } + } + + *ReserveBatteryCharge = (uint8_t) (BatteryCharge / 0.3922); + osMutexRelease(power->mux_accessPwrMan); + } +} + +void Mma_InfoSystemToUDSGetBatteryCargeState(tGpios *gpios, tOutputStatesRecord_0002 *env) { + if (GpioPinGet(&gpios->powerSusystem.battery.charge)) { + env->Output_ON_Charg = STATE_RECORD002_ON; + } else { + env->Output_ON_Charg = STATE_RECORD002_OFF; + } +} + +void Mma_InfoSystemToUDSGetMuteState(tGpios *gpios, tPowerManagement *power, tOutputStatesRecord_0002 *env) { + if (Pwm_GetMuteInCarState(power)) { + env->Output_Mute = STATE_RECORD002_ON; + } else { + env->Output_Mute = STATE_RECORD002_OFF; + } +} + +double cConvertDecToGradus(double dec) { + int deg = 0, min = 0; + double sec = 0.0; + double _dec = dec; + + deg = (int) (_dec / 100); + min = (int) (_dec) - (deg * 100); + sec = (double) (_dec - min - 100 * deg) * 60.0; + double gradus = deg + min / 60.0 + sec / 3600.0; + + return gradus; +} + +void Mma_InfoSystemToUDSGetNavData(tNmeaRmc *nmeaRmc, tVehicleCoordinates *vehicleCoordinates) { + if (nmeaRmc->status == 'A') { + + double latitude = cConvertDecToGradus(nmeaRmc->location.latitude); + double longitude = cConvertDecToGradus(nmeaRmc->location.longitude); + + vehicleCoordinates->vehicleLatitude = (uint32_t) ((latitude + 90) * 3600000); + vehicleCoordinates->vehicleLongitude = (uint32_t) ((longitude + 180) * 3600000); + } else { + vehicleCoordinates->vehicleLatitude = 0xFFFFFFFF; + vehicleCoordinates->vehicleLongitude = 0xFFFFFFFF; + } +} + +void Mma_InfoSystemToUDSGetReliabilityNavData(tNmeaRmc *nmeaRmc, uint8_t *vehicleCoordinatesReliability) { + if (nmeaRmc->status == 'A') { + *vehicleCoordinatesReliability = 1; + } else if (nmeaRmc->status == 'V') { + *vehicleCoordinatesReliability = 0; + } else { + *vehicleCoordinatesReliability = 2; + } +} + +void Mma_InfoSystemToUDSGetRegState(tGsmWithGnss *gsmWithGnss, uint8_t *gsmRegistrationState) { + if (gsmRegistrationState != NULL) { + if (gsmWithGnss->regState == AT_NETWORK_REGISTRATION_STATE_NOT_REGISTERED) { + *gsmRegistrationState = 0; + } + if (gsmWithGnss->regState == AT_NETWORK_REGISTRATION_STATE_REGISTERED_HOME) { + *gsmRegistrationState = 1; + } + if (gsmWithGnss->regState == AT_NETWORK_REGISTRATION_STATE_REGISTERED_ROAMING) { + *gsmRegistrationState = 2; + } + } +} + +void Mma_InfoSystemToUDSGetErorModemState(tGsmWithGnss *gsmWithGnss, uint8_t *gsmInnerError) { + if (gsmWithGnss->gsmState == GSM_INITIALIZING) { + *gsmInnerError = 0; + } + if (gsmWithGnss->gsmState == GSM_IDLE) { + *gsmInnerError = 1; + } + if (gsmWithGnss->gsmState == GSM_ERROR) { + *gsmInnerError = 2; + } +} + +void Mma_InfoSystemToUDSGetSimProfile(const uint8_t *SimProfile) { + SimProfile = 0; +} + +void Mma_InfoSystemGetVehCoorReliabilityMem(tNmeaRmc *nmeaRmc, uint8_t *vehicleCoordinatesReliabilityMem) { + if (nmeaRmc->status == 'A') { + *vehicleCoordinatesReliabilityMem = 1; + } else if (nmeaRmc->status == 'V') { + *vehicleCoordinatesReliabilityMem = 0; + } else { + *vehicleCoordinatesReliabilityMem = 2; + } +} + + +void Mma_InfoSystemGetEcallState(tEraGlonassUveos *eraGlonassUveos, uint8_t *EcallOn){ + if (eraGlonassUveos->fl_ecallState == true) { + *EcallOn = true; + } else { + *EcallOn = false; + } +} + +void Mma_InfoSystemToUDSGetTimeStamp(tRtcIO *rtcI0, uint32_t *TimeStamp) { + time_t timeThis; + RtcGet(rtcI0, &timeThis); + if(timeThis > 1727941386){ + *TimeStamp = timeThis; + } else { + *TimeStamp = 0xFFFFFFFF; + } +} + +void InfoToUDS_InitSetDefault(tMma *env) { + env->InputStatesRecord_0001.Input_SOS = STATE_RECORD001_UNDEFINDET; + env->InputStatesRecord_0001.Input_Service = STATE_RECORD001_UNDEFINDET; + env->InputStatesRecord_0001.Input_KL15 = STATE_RECORD001_UNDEFINDET; + env->InputStatesRecord_0001.Input_ACC = STATE_RECORD001_UNDEFINDET; + env->InputStatesRecord_0001.Reserved = STATE_RECORD001_NOT_USED; + env->InputStatesRecord_0001.Input_3 = STATE_RECORD001_NOT_USED; + env->InputStatesRecord_0001.Input_ENS = STATE_RECORD001_NOT_USED; + + env->OutputStatesRecord_0002.NotUsed1 = STATE_RECORD002_NOT_USED; + env->OutputStatesRecord_0002.Output_SOS_LED = STATE_RECORD002_NOT_USED; + env->OutputStatesRecord_0002.Output_SERVICE_LED = STATE_RECORD002_NOT_USED; + env->OutputStatesRecord_0002.NotUsed2 = STATE_RECORD002_NOT_USED; + env->OutputStatesRecord_0002.NotUsed3 = STATE_RECORD002_NOT_USED; + env->OutputStatesRecord_0002.OutputMODEM_ON = STATE_RECORD002_UNDEFINDET; + env->OutputStatesRecord_0002.OutputCheckACC = STATE_RECORD002_NOT_USED; + env->OutputStatesRecord_0002.OutputEN_CAN = STATE_RECORD002_NOT_USED; + env->OutputStatesRecord_0002.Output_ON_OFF_Mode = STATE_RECORD002_NOT_USED; + env->OutputStatesRecord_0002.Output_ON_Charg = STATE_RECORD002_UNDEFINDET; + env->OutputStatesRecord_0002.Output_RED_LED = STATE_RECORD002_UNDEFINDET; + env->OutputStatesRecord_0002.Output_GREEN_LED = STATE_RECORD002_UNDEFINDET; + env->OutputStatesRecord_0002.Output_EN_VMIC = STATE_RECORD002_NOT_USED; + env->OutputStatesRecord_0002.Output_Modem_Wake = STATE_RECORD002_NOT_USED; + env->OutputStatesRecord_0002.Output_Modem_Reset = STATE_RECORD002_UNDEFINDET; + env->OutputStatesRecord_0002.Output_Mute = STATE_RECORD002_UNDEFINDET; + + env->SystemStateID_0006.Comfort_State = 2; + env->SystemStateID_0006.Airbag_State = 5; + env->SystemStateID_0006.TCM_State = 1; + env->SystemStateID_0006.Reserved2 = 2; + env->SystemStateID_0006.Battery_State = 7; + env->SystemStateID_0006.Motion_State = 3; + env->SystemStateID_0006.Reserved3 = 2; + env->SystemStateID_0006.RolloverAngleStatus = 0; + env->SystemStateID_0006.GSM_State = INITIALIZING; + + env->state.GsmInnerError = 0; + env->state.GsmRegistrationState = 0; + env->state.VehicleCoordinates.vehicleLongitude = 0xFFFFFFFF; + env->state.VehicleCoordinates.vehicleLatitude = 0xFFFFFFFF; + env->state.VehicleCoordinatesReliability = 2; + env->state.ReserveBatteryTemperature = 80; +} + +void Mma_InfoSystemGetGSMSoftwareVersionNumber(tString32 *env, const bool *modemState, char *GSMSoftwareVersionNumber){ + if(*modemState == true) { + uint8_t length = env->length; + if(length>20){ + length = 20; + } + memcpy(GSMSoftwareVersionNumber, env->data, length); + } +} + +void Mma_InfoSystemToUDSGetGsmRegistrationError(tGsmWithGnss *gsmWithGnss, const bool *modemState, uint8_t *GsmRegistrationError){ + if(*modemState == true) { + if (GsmRegistrationError != NULL) { + if ( + gsmWithGnss->regState == AT_NETWORK_REGISTRATION_STATE_REGISTERED_HOME || + gsmWithGnss->regState == AT_NETWORK_REGISTRATION_STATE_REGISTERED_ROAMING + ) { + *GsmRegistrationError = 1; + } else if (gsmWithGnss->regState == AT_NETWORK_REGISTRATION_STATE_REGISTRATION_DENIED) { + *GsmRegistrationError = 2; + } else { + *GsmRegistrationError = 0; + } + } + } +} + +static _Noreturn void Mma_InfoSystemToUDSThread(tMma *env) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Поток передачи состояния устройства через UDS протокол запущен") +// GsmRegistartionStateMem + while (1) { + + env->state.MDS_FormatVersion = 2; + Mma_InfoSystemToUDSGetSimProfileAmount(&env->state.SimProfileAmount); + Mma_InfoSystemToUDSGetTCMTimeCalculation(&env->state.TCM_time_calculation); + Mma_InfoSystemToUDSGetBoardVoltage(&env->power, &env->state.BoardVoltage); + Mma_InfoSystemToUDSGetBatteryCharge(&env->power, &env->state.ReserveBatteryCharge); + Mma_InfoSystemToUDSGetTimeStamp(&env->rtc->rtcI0, &env->state.TimeStamp); + Mma_InfoSystemToUDSGetSimProfile(&env->state.SimProfile); + Mma_InfoSystemToUDSGetErorModemState(&env->gsmWithGnss, &env->state.GsmInnerError); + Mma_InfoSystemToUDSGetRegState( &env->gsmWithGnss, &env->state.GsmRegistrationState); + Mma_InfoSystemToUDSGetNavData(&env->gsmWithGnss.gnss.currentRmc, &env->state.VehicleCoordinates); + Mma_InfoSystemToUDSGetReliabilityNavData(&env->gsmWithGnss.gnss.currentRmc, &env->state.VehicleCoordinatesReliability); + Mma_InfoSystemToUDSGetInputLinesState(env->gpios, &env->InputStatesRecord_0001); + Mma_InfoSystemToUDSGetModemResetState(env->gpios, &env->power, &env->OutputStatesRecord_0002); + Mma_InfoSystemToUDSGetRedLedState(env->gpios, &env->OutputStatesRecord_0002); + Mma_InfoSystemToUDSGetRedGreenState(env->gpios, &env->OutputStatesRecord_0002); + Mma_InfoSystemToUDSGetBatteryCargeState(env->gpios, &env->OutputStatesRecord_0002); + Mma_InfoSystemToUDSGetMuteState(env->gpios, &env->power, &env->OutputStatesRecord_0002); + Mma_InfoSystemToUDSpowerStatus(env->gpios, &env->power, &env->OutputStatesRecord_0002); + Mma_InfoSystemToUDSGetModemState(&env->ModemDataCollector, &env->indication.mode, &env->SystemStateID_0006); + Mma_InfoSystemToUDSGetBattaryState(&env->power, &env->SystemStateID_0006); + Mma_InfoSystemToUDSGetMotionState(&env->power, &env->SystemStateID_0006); + + Mma_InfoSystemToUDSGetGsmRegistrationError( + &env->gsmWithGnss, + &env->ModemDataCollector.fl_IsLoad, + &env->state.GsmRegistrationError + ); + + Mma_InfoSystemGetGSMSoftwareVersionNumber( + &env->ModemDataCollector.modemVersionRevision.softValue, + &env->ModemDataCollector.fl_IsLoad, + env->state.GSMSoftwareVersionNumber + ); + SystemDelayMs(4); + } +} + + +void TMR2_CanMute_Start(tMma *env){ + crm_clocks_freq_get(&crm_clocks_freq_structure); + crm_periph_clock_enable(CRM_TMR8_PERIPH_CLOCK, TRUE); + uint32_t tmr = (crm_clocks_freq_structure.apb2_freq * 2 / 10000) - 1; + tmr = tmr/100; + tmr_base_init(TMR8, 9990, tmr); + tmr_cnt_dir_set(TMR8, TMR_COUNT_UP); + tmr_interrupt_enable(TMR8, TMR_OVF_INT, TRUE); + nvic_priority_group_config(NVIC_PRIORITY_GROUP_4); + nvic_irq_enable(TMR8_OVF_TMR13_IRQn, 0x59, 0); + tmr_counter_enable(TMR8, TRUE); + uint32_t tmStop = SystemGetMs() - env->tmStart; + tmStop = tmStop; +} + +//uint32_t tm; +//uint16_t ms[1000]; +//volatile uint16_t i = 0; +//volatile uint16_t o = 0; +//volatile uint32_t ttt = 0; +//volatile uint32_t aa = 0; +void TMR8_OVF_TMR13_IRQHandler() +{ + if(tmr_interrupt_flag_get(TMR8, TMR_OVF_FLAG) == SET) + { + if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) { + EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_GNSS); + +// if(o == 1000){ +// o=0; +// } +// aa = SystemGetMs(); +// if(ttt > aa){ +// ++i; +// } else { +// ms[o] = i; +// i=0; +// o++; +// ttt = SystemGetMs()+1000; +// } + } + tmr_flag_clear(TMR8, TMR_OVF_FLAG); + } +} + +void UserInputInfoSystemToUDS(tMma *env) { + InitThreadAtrStatic(&env->threadToUDS_Info.attr, "Thread_Uds", env->threadToUDS_Info.controlBlock, + env->threadToUDS_Info.stack, osPriorityNormal); + if (!env->threadToUDS_Info.id) { + env->threadToUDS_Info.id = osThreadNew( + (osThreadFunc_t) (Mma_InfoSystemToUDSThread), + (void *) (env), + &env->threadToUDS_Info.attr + ); + } +} diff --git a/MainModesArbiter.c b/MainModesArbiter.c new file mode 100644 index 0000000..57beb9d --- /dev/null +++ b/MainModesArbiter.c @@ -0,0 +1,1633 @@ + +// flash sector + +// uint8_t packet[] = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; +// env->signature.atCmd = &env->gsmWithGnss.gsmAt; +// env->signature.slog = &env->slog; +//// while (1){ +// EraTSK_GetPackSignature(&env->signature,packet,sizeof(packet)); +// SystemDelayMs(10); +// // SystemDelayMs(1); +//// } +// return; + + +// +// Created by xemon on 19.09.22. +// +//+79419776358 +// +79418100029 + +#include "MainModesArbiter_Private.h" +#include "BootJump.h" +#include "DeviceTesting_TestsWithUser.h" +#include "AtGsmOpenAudioLoop.h" +#include "egts.h" +#include "AsciiStringAssmeblingUtils.h" +#include "AtGsmSms_DeleteAll.h" +#include "DeviceTesting.h" +#include "stream.h" +//#include "PointEvent.h" +#include "DeviceTesting_TestingMethods.h" +#include "Accel.h" +#define LOG_SIGN "Главн." +#define LOGGER &env->slog.logger + +size_t str_len = 0; +char step[5] = {0}; + +void Mma_Init( + tMma *env, + tGpios *gpios, + tSerialPorts *serialPorts, + tI2cPorts *i2cPorts, + tSpiPorts *spiPorts, + tAdcs *adcs, + tStorageOnFlash *flash, + tRtcs *rtc, + tCanPorts *canPorts +) { + env->accel = &ACCEL; + env->gpios = gpios; + env->serialPorts = serialPorts; + env->i2cPorts = i2cPorts; + env->spiPorts = spiPorts; + env->canPorts = canPorts; + env->adcs = adcs; + env->flash = flash; + env->rtc = rtc; + InitThreadAtrStatic(&env->thread.attr, "Mma", env->thread.controlBlock, env->thread.stack, osPriorityNormal); + env->thread.id = 0; + env->lastSmsCheckTime = SystemGetMs() + 8000; + env->flIgn = false; + env->userInputSubstart = 0; + env->mux_factoryMode = osMutexNew(NULL); + env->tmt = SystemGetMs() + 5000; + env->tm_FactoryMessage = SystemGetMs() + 5000; + env->fl_iniSysIsDone = false; + env->checNetDeGeg = false; + env->eolAcsess = false; + env->fl_isFacrotyMode = false; + env->telematicaIsConnect = TELE_ACSESS_TEMPORARY; +} + + /* +void Mma_SetAccessProtection(){ + flash_status_type status = FLASH_OPERATE_DONE; + if(flash_fap_status_get() == RESET) { + flash_unlock(); + status = flash_operation_wait_for(OPERATION_TIMEOUT); + if (status != FLASH_OPERATE_TIMEOUT) { + if ((status == FLASH_PROGRAM_ERROR) || (status == FLASH_EPP_ERROR)) + flash_flag_clear(FLASH_PRGMERR_FLAG | FLASH_EPPERR_FLAG); + status = flash_fap_enable(TRUE); + if (status == FLASH_OPERATE_DONE){ + //nvic_system_reset(); + } + flash_lock(); + } + flash_lock(); + } +} +*/ + + +static _Noreturn void Mma_AccompanModeThread(tMma *env) { + while (1) { + Mma_AccompanMode(env); + SystemDelayMs(40); + } +} + + +void AccompanModeStartThread(tMma *env) { + if (!env->threadAccompanMode.id) { + env->threadAccompanMode.id = osThreadNew( + (osThreadFunc_t) (Mma_AccompanModeThread), + (void *) (env), + &env->threadAccompanMode.attr + ); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сопроводительный поток запущен") + } +} + +void AccompanModeStopThread(tMma *env) { + if (env->threadAccompanMode.id != NULL) { + if (osThreadTerminate(env->threadAccompanMode.id) == osOK) { + SystemDelayMs(100); + env->threadAccompanMode.id = NULL; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сопроводительный поток остановлен") + SystemDelayMs(500); + } + } +} + +// не трогать дэлэи !!! +void Mma_AudioSubSystemStart(tPowerManagement *power, tAmplifier *amplifier) { + Pwm_SetMuteInCar(power, true); + SystemDelayMs(100); + Mma_AudioTestSetMode(power, false); + SystemDelayMs(200); + Pwm_AmpOn(power); + SystemDelayMs(800); + Amplifier_StartUp(amplifier); + SystemDelayMs(1600); +} +/* +void Mma_ShortShutdown(tMma *env) { + if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) { + EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_SHUTDOWN); + } + + Pwm_GsmAndGnssShutDown(&env->power); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Завершение работы") + VarsTabDumpObserver_Flush(&env->storage.dumpObserver); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение питания через 4 с") + SystemDelayMs(4000); + Pwm_Blackout(&env->power); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Питание осталось, обратите внимание!!") + LoggerInfoStatic(LOGGER, LOG_SIGN, "Возможно произошло повторное включение пользователем") + env->eolAcsess = false; + SystemDelayMs(500); + + nvic_system_reset(); + //BootJumpToAddress(0x8000000); + LoggerErrorStatic(LOGGER, LOG_SIGN, "Этой строчки не должно быть! Критическая ошибка!") +} +*/ + +void Mma_Shutdown(tMma *env) { + if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) { + EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_SHUTDOWN); + } + + Pwm_GsmAndGnssShutDown(&env->power); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Завершение работы") + VarsTabDumpObserver_Flush(&env->storage.dumpObserver); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение питания через 4 с") + SystemDelayMs(4000); + Pwm_Blackout(&env->power); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Питание осталось, обратите внимание!!") + LoggerInfoStatic(LOGGER, LOG_SIGN, "Возможно произошло повторное включение пользователем") + env->eolAcsess = false; + SystemDelayMs(500); + + nvic_system_reset(); + //BootJumpToAddress(0x8000000); + LoggerErrorStatic(LOGGER, LOG_SIGN, "Этой строчки не должно быть! Критическая ошибка!") +} + +void Mma_CheckShutdownIsBattary(tMma *env) { + bool statShutdown = Pwm_IsShutdownRequired(&env->power); + if ((env->indication.mode != DEVICE_MODE_TESTING) && (env->indication.mode != DEVICE_MODE_UVEOS_GARAG)) { + if (statShutdown) { + uint16_t single; + float volt; + single = env->power.powerSusystem->battery.currentBatVoltage; + volt = (float) single / 1000; + if (volt < 2.0) { + LoggerTraceStatic(LOGGER, LOG_SIGN, "===================================================") + LoggerTraceStatic(LOGGER, LOG_SIGN, "ОТКЛЮЧЕНИЕ УСТРОЙСТВА ПО ДОСТИЖЕНИЮ КРИТИЧЕСКИ НИЗКОГО") + LoggerTraceStatic(LOGGER, LOG_SIGN, " УРОВНЯ ЗАРЯДА РЕЗЕРВНОГО ИСТОЧНИКА ПИТАНИЯ") + LoggerTraceStatic(LOGGER, LOG_SIGN, "===================================================") + Mma_Shutdown(env); + } + } + } +} + +void Mma_AudioTestSetMode(tPowerManagement *env, bool fl) { + env->powerSusystem->SpekTestPower.speakTestAcsess = fl; +} + +void Mma_CheckShutdown(tMma *env) { + if (env->fl_iniSysIsDone == false) { + return; + } + + bool statIgnition = Pwm_IsShutdownRequired(&env->power); // ignition + bool statIsNetwork = EraGlonassUveos_IsStandby(&env->uveos); // timings.requireNetwork + bool statStandFulPower = EraGlonassUveos_IsAllowInCall(&env->uveos); // timings.allowInCall + bool statTestTimer = EraGlonassUveos_IsStandbyTestTimer(&env->uveos); + + if ((statIsNetwork && statTestTimer) && (statStandFulPower) && (!statIgnition)) { + SystemSelector(&env->systemSwitcher, UVEOS); + } + + if ((statIgnition) && (!statIsNetwork) && (!statStandFulPower)) { + Mma_Shutdown(env); + } + + Mma_CheckShutdownIsBattary(env); +} + +void Mma_SetNetworkRegistration(tMma *env, bool value) { + if (value == true) { + if (env->gsmWithGnss.isRegToGSM == false) { + LoggerTraceStatic(LOGGER, LOG_SIGN, "Инициализирована автоматическая регистрация из сети наземной связи") + if (GsmWithGnss_NetworkSetStateInnaterups(&env->gsmWithGnss, 4, 4000) == AT_ERROR) { + env->tmpTm = SystemGetMs() + 10000; + while ( + (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 1500) == false) && + (env->tmpTm > SystemGetMs()) + ) { + SystemDelayMs(1000); + } + } else { + LoggerTraceStatic(LOGGER, LOG_SIGN, "Регистрация в сети присутствует, код 4") + } + } + } else { + if (env->gsmWithGnss.isRegToGSM == true) { + LoggerTraceStatic(LOGGER, LOG_SIGN, "Инициализирована автоматическая деригистрация из сети наземной связи") + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt); + SystemDelayMs(1000); + AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt); + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } + if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 1500) == true) { + env->tmpTm = SystemGetMs() + 10000; + while ( + (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 1500) == true) && + (env->tmpTm > SystemGetMs()) + ) { + SystemDelayMs(1000); + } + } else { + LoggerTraceStatic(LOGGER, LOG_SIGN, "Деригистрация в сети выполнена, код 4") + } + } + } +} + +void Mma_CanProcRunTests(tMma *env) { + tDeviceModes indicationState = env->indication.mode; + +// eSubSystems eSubSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + if (env->queryUDSState.source != SPEAK_MICR_TEST) { + SystemSelector(&env->systemSwitcher, UVEOS); + } + + Mma_RunUserTests(env, true); + + env->indication.mode = indicationState; + Mma_SetMode(env, indicationState); +} + +tDeviceModes *UserIndication_GetMode(tMma *env) { + return &env->indication.mode; +} + +void Mma_GarageMode(tMma *env) { + AccompanModeStopThread(env); + Mma_AudioSubSystemStart(&env->power, &env->amplifier); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим Гараж") + GpioPinEnable(&env->power.powerSusystem->main.garage); + + SystemDelayMs(40); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "servise_mode.mp3", 4 * 1000); + Mma_AudioSubSystemRelease(env); + + env->storage.nvm->device.serviseMode = true; + DeviceStorage_ForceDump(&env->storage); + + EraGlonassUveos_GarageStarted(&env->uveos); + tUserInputButtonEvent buttonEvent = {0}; + while (1) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим Гараж") + + if (DeviceTesting_Periodical(&env->testing)) { + Mma_SetMode(env, DEVICE_MODE_FAILURE); + } else { + Mma_SetMode(env, DEVICE_MODE_UVEOS_GARAG); + } + + if (env->storage.runtime.enableGnssUpdate) { + EraGlonassUveos_DoNothingModeDistance(&env->uveos, true); + } + + if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_DISABLED) { + Mma_SetMode(env, DEVICE_MODE_UVEOS_UNDEFINDET); + AccompanModeStartThread(env); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Автоматический выход из режима Гараж") + GpioPinDisable(&env->power.powerSusystem->main.garage); + env->storage.nvm->device.serviseMode = false; + DeviceStorage_ForceDump(&env->storage); + EraGlonassUveos_DoNotingReset(&env->uveos); + + Mma_AudioSubSystemRequire(env); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "era_mode.mp3", 4 * 1000); + Mma_AudioSubSystemRelease(env); + + uint32_t tm = SystemGetMs() + 1000; + while (tm < SystemGetMs()) {} + return; + } + + if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) { + if (UserInputButtonEventIsBetween(buttonEvent, UI_VIRT_BUTTON_ADDITIONAL, RAISE, SERVICE_MODE_MIN, SERVICE_MODE_MAX)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Пользовательский выход из режима Гараж") + Mma_SetMode(env, DEVICE_MODE_UVEOS_UNDEFINDET); + AccompanModeStartThread(env); + GpioPinDisable(&env->power.powerSusystem->main.garage); + env->storage.nvm->device.serviseMode = false; + DeviceStorage_ForceDump(&env->storage); + EraGlonassUveos_DoNotingReset(&env->uveos); + + Mma_AudioSubSystemRequire(env); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "era_mode.mp3", 4 * 1000); + + uint32_t tm = SystemGetMs() + 1000; + while (tm < SystemGetMs()) {} + + Mma_AudioSubSystemRelease(env); + return; + } + } + + + Mma_CheckShutdown(env); + SystemDelayMs(500); + } +} + +void Mma_SubstartTelematica(tMma *env) { + env->uveos.doNothing.mode = UVEOS_DO_NOTHING_DISABLED; + bool statIgnition = Pwm_IsShutdownRequired(&env->power); // ignition + bool statIsNetwork = EraGlonassUveos_IsStandby(&env->uveos); // timings.requireNetwork + bool statStandFulPower = EraGlonassUveos_IsAllowInCall(&env->uveos); // timings.allowInCall + bool statTestTimer = EraGlonassUveos_IsStandbyTestTimer(&env->uveos); + + if (env->fl_iniSysIsDone == true) { + if ((!statIsNetwork && !statTestTimer) && (!statStandFulPower) && (!statIgnition)) { + if ((env->telematicaIsConnect == TELE_ACSESS_LOCAL) || (env->telematicaIsConnect == TELE_ACSESS_SERVER)) { + SystemSelector(&env->systemSwitcher, TELEMATICA); + } + + if (env->telematicaIsConnect == TELE_ACSESS_TEMPORARY) { + SystemSelector(&env->systemSwitcher, TELEMATICA); + } + + if (env->storage.nvm->device.telematicaIsActive) { + env->telematicaIsConnect = TELE_ACSESS_LOCAL; + } + + if (env->storage.runtime.telematicaServerIsActive) { + env->telematicaIsConnect = TELE_ACSESS_SERVER; + } + + if (env->telematicaIsConnect == TELE_ACSESS_DENATED) { + SystemSelector(&env->systemSwitcher, UVEOS); + } + } else { + SystemSelector(&env->systemSwitcher, UVEOS); + } + + if ( + (env->storage.runtime.telematicaWaitConnect == true) && + (env->storage.nvm->device.telematicaIsActive == false) && + (env->storage.runtime.telematicaServerIsActive == false) + ) { + env->telematicaIsConnect = TELE_ACSESS_DENATED; + } + + } +} + +bool flSubSys = false; +bool flCrashDetectionStat = false; +uint32_t tmt = 0; + +void Mma_AccompanMode(tMma *env) { + + if (env->eolAcsess == true) { + Mma_ClearParams(env); + DeviceStorage_ForceDump(&env->storage); + Mma_Shutdown(env); + } + + if ((env->threadSubstartChekButton.id == NULL) && (flSubSys == false)) { + Mma_UserInputSubstartButtonThreadStart(env); + flSubSys = true; + } + + if (!env->storage.nvm->device.factoryMode) { + + if ((*env->comInt.Amplifier.playMode == true)&&(env->ModemDataCollector.fl_IsLoad == true)) { + Mma_AudioSubSystemRequire(env); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000); + *env->comInt.Amplifier.playMode = false; + Mma_AudioSubSystemRelease(env); + } + + if (env->comInt.TestButton.run == true) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование из сервисного ПО") + env->testing.audioHintsMode = HINTS_NORMAL; + Mma_RunShortTest(env, true); + env->testing.audioHintsMode = HINTS_FULL; + env->comInt.TestButton.run = false; + } + + if (env->crashDetect.carCrashDetection.isStarted == false) { + if (Mma_StartCrachDetectSubsystem(env) == true) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Подсистема Crash Detect запущена, запуск инициализирован из сопроводительно потока") + } else { + if(tmt < SystemGetMs()) { + tmt = SystemGetMs()+10000; + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Опорные данные для работы акселерометра не установлены, повторная попытка запуска Crash Detect") + } + } + } else { + if (flCrashDetectionStat == false) { + flCrashDetectionStat = true; + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Запуск Crash Detect не требуется, подсистема уже запущена") + } + } + + tDeviceModes *deviceModes = UserIndication_GetMode(env); + if (DeviceTesting_Always(&env->testing)) { + if ((*deviceModes != DEVICE_MODE_TESTING) && + (*deviceModes != DEVICE_MODE_UVEOS_PASSIVE) + ) { + *deviceModes = DEVICE_MODE_FAILURE; + } + } else { + if (env->fl_iniSysIsDone == true) { + if ((*deviceModes != DEVICE_MODE_TESTING) && + (*deviceModes != DEVICE_MODE_UVEOS_PASSIVE)&& + (*deviceModes != DEVICE_MODE_UVEOS_GARAG) + ){ + *deviceModes = DEVICE_MODE_UVEOS_UNDEFINDET; + } + } + } + + if (*deviceModes != DEVICE_MODE_FAILURE) { + if (DeviceTesting_Periodical(&env->testing)) { + if ((*deviceModes != DEVICE_MODE_TESTING) && (*deviceModes != DEVICE_MODE_UVEOS_PASSIVE)) { + *deviceModes = DEVICE_MODE_FAILURE; + } + } else { + if ((*deviceModes != DEVICE_MODE_TESTING) && + (*deviceModes != DEVICE_MODE_UVEOS_PASSIVE)&& + (*deviceModes != DEVICE_MODE_UVEOS_GARAG) + ) { + *deviceModes = DEVICE_MODE_UVEOS_UNDEFINDET; + } + } + } + + if ((env->fl_iniSysIsDone) && + (*deviceModes != DEVICE_MODE_TESTING) && + (*deviceModes != DEVICE_MODE_UVEOS_PASSIVE) && + (*deviceModes != DEVICE_MODE_UVEOS_GARAG) + ) + { + Mma_SetMode(env, *deviceModes); + Mma_gnssUpdateIndication(env); + } + SystemDelayMs(500); + return; + } + + ///============================================================================================= + // раскерпичиватель модема + if (env->storage.nvm->device.factoryMode) { + if (DeviceTestsTable_MakeTest(env->testing.namedTests.vin) == DEVICE_TESTING_CODE_PASSED) { + env->storage.nvm->device.factoryMode = false; + EraGlonassUveosDumper_ForceDump(env->uveos.dumper); + uint32_t tmtt = SystemGetMs() + 4000; + while (tmtt > SystemGetMs()) { + SystemDelayMs(40); + } + } + } + + env->playMode = true; + if ( + (env->storage.nvm->device.factoryMode) && + (osMutexAcquire(env->mux_factoryMode, 5000)) + ) { + + tDeviceModes *deviceModes; + DeviceTesting_SetTelematicaTestMode(&env->testing, true); + Mma_UserInputSubstartButtonThreadStop(env); + + +#ifdef FIRMWARE_TEST + if ((env->playMode == true) && (env->ModemDataCollector.fl_IsLoad == true)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим производственного контроля") + env->playMode = false; + } +#else + if ((env->playMode == true) && (env->ModemDataCollector.fl_IsLoad == true)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим производственного контроля") + SystemDelayMs(1000); + Mma_AudioSubSystemRequire(env); + SystemDelayMs(1000); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000); + env->playMode = false; + Mma_AudioSubSystemRelease(env); + } +#endif + + bool fl_triger = true; + while (1) { + SystemSelector(&env->systemSwitcher, TELEMATICA); + if (env->tm_FactoryMessage < SystemGetMs()) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим производственного контроля") + env->tm_FactoryMessage = SystemGetMs() + 15000; + } + + deviceModes = UserIndication_GetMode(env); + + if (!env->storage.nvm->device.factoryMode) { + osMutexRelease(env->mux_factoryMode); + return; + } + +#ifdef FIRMWARE_TEST + if ((env->playMode == true) && (env->ModemDataCollector.fl_IsLoad == true)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим производственного контроля") + env->playMode = false; + } + +#else + if ((env->playMode == true) && (env->ModemDataCollector.fl_IsLoad == true)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим производственного контроля") + SystemDelayMs(1000); + Mma_AudioSubSystemRequire(env); + SystemDelayMs(1000); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000); + env->playMode = false; + Mma_AudioSubSystemRelease(env); + } +#endif + if ((*env->comInt.Amplifier.playMode == true)&&(env->ModemDataCollector.fl_IsLoad == true)) { + Mma_AudioSubSystemRequire(env); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000); + *env->comInt.Amplifier.playMode = false; + Mma_AudioSubSystemRelease(env); + } + + if (env->comInt.TestButton.run == true) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование из сервисного ПО") + env->testing.audioHintsMode = HINTS_NORMAL; + Mma_RunShortTest(env, true); + env->testing.audioHintsMode = HINTS_FULL; + env->comInt.TestButton.run = false; + } + + if (fl_triger == true) { + SystemSelector(&env->systemSwitcher, TELEMATICA); + fl_triger = false; + } + + if (DeviceTesting_Always(&env->testing)) { + if (*deviceModes != DEVICE_MODE_TESTING) { + *deviceModes = DEVICE_MODE_FAILURE; + } + } else { + if (env->fl_iniSysIsDone == true) { + if (*deviceModes != DEVICE_MODE_TESTING) { + *deviceModes = DEVICE_MODE_UVEOS_UNDEFINDET; + } + } + } + + if (*deviceModes != DEVICE_MODE_FAILURE) { + if (DeviceTesting_Periodical(&env->testing)) { + if (*deviceModes != DEVICE_MODE_TESTING) { + *deviceModes = DEVICE_MODE_FAILURE; + } + } else { + if (*deviceModes != DEVICE_MODE_TESTING) { + *deviceModes = DEVICE_MODE_UVEOS_UNDEFINDET; + } + } + } + + if ( + (env->fl_iniSysIsDone) && + (*deviceModes != DEVICE_MODE_TESTING) && + (*deviceModes != DEVICE_MODE_UVEOS_GARAG) + ) { + + Mma_SetMode(env, *deviceModes); + Mma_gnssUpdateIndication(env); + } + + if (!env->storage.nvm->device.factoryMode) { + DeviceTestsTable_MakeTest(env->testing.namedTests.modemSimEra); + DeviceTestsTable_MakeTest(env->testing.namedTests.modemSimComers); + DeviceTestsTable_MakeTest(env->testing.namedTests.modemSoftRevision); + + DeviceTesting_SetTelematicaTestMode(&env->testing, false); + SystemDelayMs(1000); + Mma_AudioSubSystemRequire(env); + SystemDelayMs(1000); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "era_mode.mp3", 4 * 1000); + Mma_AudioSubSystemRelease(env); + + if ((env->userInputSubstart == 1) || (env->userInputSubstart == 2)) { + SystemSelector(&env->systemSwitcher, UVEOS); + ModemDataCollector_SelectionSimChip(&env->systemSelector, CHIP_ERA); + } else { + SystemSelector(&env->systemSwitcher, TELEMATICA); + } + + if (env->threadSubstartChekButton.id == NULL) { + Mma_UserInputSubstartButtonThreadStart(env); + } + + osMutexRelease(env->mux_factoryMode); + env->fl_isFacrotyMode = true; + EraGlonassUveosDumper_ForceDump(&env->storage.uveosDumper); + SystemDelayMs(100); + return; + } + + Mma_RunTests(env); + +#ifdef FIRMWARE_TEST + if ((*env->comInt.Amplifier.playMode == true)&&(env->ModemDataCollector.fl_IsLoad == true)) { + *env->comInt.Amplifier.playMode = false; + } +#else + if ((*env->comInt.Amplifier.playMode == true)&&(env->ModemDataCollector.fl_IsLoad == true)) { + Mma_AudioSubSystemRequire(env); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000); + *env->comInt.Amplifier.playMode = false; + Mma_AudioSubSystemRelease(env); + } +#endif + if (env->comInt.TestButton.run == true) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование из сервисного ПО") + env->testing.audioHintsMode = HINTS_NORMAL; + Mma_RunShortTest(env, true); + env->testing.audioHintsMode = HINTS_FULL; + env->comInt.TestButton.run = false; + } + + Mma_CheckShutdown(env); + SystemDelayMs(100); + } + } +} + +void Mma_RunTests(tMma *env) { + if (env->testing.queryUDSState->commands == COM_RUN) { + Mma_CanProcRunTests(env); + if (env->storage.nvm->device.factoryMode == true) { + SystemSelector(&env->systemSwitcher, TELEMATICA); + } + } +} + +void Mma_AudioSubSystemRelease(tMma *env) { + if (!env->storage.nvm->gost.notGost.ECALL_DEBUG_MODE) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализировано освобождение аудио подсистемы") + Pwm_SetMuteInCar(&env->power, false); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сигнал MUTE снят с борт. сети") + Pwm_AmpOff(&env->power); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение УНЧ выполнено") + SystemDelayMs(200); + Mma_AudioTestSetMode(&env->power, true); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Тест наличия громкоговорителя включен код 2") + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "СИСТЕМА В РЕЖИМЕ ОТЛАДКИ, ОТКЛЮЧЕНИЕ АУДИО ПОДСИСТЕМЫ НЕ ВОЗМОЖЕН") + } +} + +void Mma_AudioSubSystemRequire(tMma *env) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Включение аудио тракта") + Mma_AudioSubSystemStart(&env->power, &env->amplifier); +} + +void Mma_NetworkRequire(tMma *env) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Проверка регистрацию в сети") + if (!GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 1500)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует, попытка регистрации код 2") + Mma_SetMode(env, DEVICE_MODE_UVEOS_WAIT_NETWORK); + if (GsmWithGnss_NetworkSetStateInnaterups(&env->gsmWithGnss, 4, 20000) == AT_OK) { + LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть присутствует") + return; + } else { + LoggerErrorStatic(LOGGER, LOG_SIGN, "нет сети") + } + } else { + LoggerErrorStatic(LOGGER, LOG_SIGN, "Регистрация в сети присутствует") + } +} + +void Mma_gnssUpdateIndicationGetGnssState(tMma *env) { + if ((env->storage.runtime.enableGnssUpdate == true) && (env->indication.mode != DEVICE_MODE_TESTING) && + (env->indication.mode != DEVICE_MODE_UVEOS_GARAG)) { + if (env->gsmWithGnss.gnss.currentRmc.status == 'A') { + if (ModemDataCollector_GetThisSubSystem(&env->systemSelector) == UVEOS) { + EraGlonassUveos_DoNothingModeDistance(&env->uveos, true); + } + Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY); + } else { + Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_WAIT_GNSS); + env->uveos.doNothing.mode = UVEOS_DO_NOTHING_DISABLED; + SystemDelayMs(10); + } + + if (GsmWithGnss_IsGnssReady(&env->gsmWithGnss)) { + env->indication.mode = DEVICE_MODE_UVEOS_ERA_GNSS_READY; + } else { + env->indication.mode = DEVICE_MODE_UVEOS_ERA_WAIT_GNSS; + } + + } else { + if (env->gsmWithGnss.gnss.currentRmc.status == 'A') { + if (ModemDataCollector_GetThisSubSystem(&env->systemSelector) == UVEOS) { + EraGlonassUveos_DoNothingModeDistance(&env->uveos, true); + } + Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY); + } else { + Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_WAIT_GNSS); + } + } +} + +void Mma_gnssUpdateIndication(tMma *env) { +// Mma_gnssUpdateIndicationGetGnssState(env); + if (env->indication.mode != DEVICE_MODE_FAILURE) { + Mma_gnssUpdateIndicationGetGnssState(env); + } + if (env->indication.mode == DEVICE_MODE_UVEOS_UNDEFINDET) { + Mma_gnssUpdateIndicationGetGnssState(env); + } +} + +static void Mma_UserTestMode(tMma *env,bool exitTestPlay) { + + if (env->testing.queryUDSState->source == GSM_TEST) { + Mma_NetworkRequire(env); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "reg_to_net.mp3", 4 * 1000); + } + + EraGlonassUveos_DoNotingTestingStarted(&env->uveos); + + if (DeviceTesting_RunUserTests(&env->testing) == true) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Пользовательское тестирование завершено") + if (!env->storage.nvm->device.factoryMode) { + SystemDelayMs(500); + Mma_AudioSubSystemRequire(env); + SystemDelayMs(500); + if(exitTestPlay == true) { + DeviceTesting_ExitTestPlay(&env->testing); + } + } + } + Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY); +} + +void Mma_RunUserTests(tMma *env, bool releaseAudioSubSystem) { + + if (env->indication.mode == DEVICE_MODE_TESTING) { + return; + } + + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_ACTIVE + ); + Mma_SetMode(env, DEVICE_MODE_TESTING); + + Mma_AudioSubSystemRequire(env); +#if (AURUS_CAR_UI == 1) + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "runTestAurus.mp3", 4 * 1000); +#endif + + vAsciiStringInit(step, &str_len, 5); + vAsciiStringAddDecimalInt64(step, &str_len, env->uveos.doNothing.movDist, 5); + eSubSystems subSystemsBuf = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + + if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_DISABLED) { + + if (env->testing.queryUDSState->source != LEDS_TEST) { +#if (AURUS_CAR_UI == 1) + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "autoDiagnost.mp3", 5 * 1000); +#endif +#if (AURUS_CAR_UI == 0) + if ( + (env->testing.audioHintsMode != HINTS_MINIMAL) && + (env->testing.audioHintsMode != HINTS_NOT_ERA_EXIT)) { + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000); + } + if (env->testing.audioHintsMode == HINTS_NOT_ERA_EXIT) { + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000); + env->testing.audioHintsMode = HINTS_MINIMAL; + } +#endif + } + + SystemSelector(&env->systemSwitcher, UVEOS); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим пользовательского тестирования, отклонение дистанции=") + LoggerInfo(LOGGER, LOG_SIGN, step, str_len) + + Mma_UserTestMode(env,releaseAudioSubSystem); + + if(releaseAudioSubSystem == true) { + Mma_AudioSubSystemRelease(env); + } + + env->testing.queryUDSState->commands = COM_INIT; + SystemSelector(&env->systemSwitcher, subSystemsBuf); + + } else if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_MOVE_TO) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Переход в режим тестирования не возможен, Т.С. находится в движении, отклонение дистанции=") + LoggerInfo(LOGGER, LOG_SIGN, step, str_len) + } else if (env->uveos.doNothing.movePosition.valid == 0) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Данные GNSS не достоверны!") + } + + env->testing.queryUDSState->state = QUERY_STOP; + + if(releaseAudioSubSystem == true) { + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_NOT_ACTIVE + ); + } + Mma_SetMode(env, DEVICE_MODE_UVEOS_UNDEFINDET); +} + + +void Mma_CheckingChangesGNSS_Antena(tMma *env) { + if (env->storage.nvm->device.useInternalAnt != env->power.interAntBufVal) { + Pwm_LNA_setMode(&env->power, env->storage.nvm->device.useInternalAnt); + } + env->power.interAntBufVal = env->storage.nvm->device.useInternalAnt; +} + +void Mma_RunServiceMode(tMma *env) { + vAsciiStringInit(step, &str_len, 5); + vAsciiStringAddDecimalInt64(step, &str_len, env->uveos.doNothing.movDist, 5); + eSubSystems subSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + if (subSystemsTmp != TELEMATICA) { + if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) { + ///* переключение в режим телематики + SystemSelector(&env->systemSwitcher, TELEMATICA); + EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_START); + } + } + + if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_DISABLED) { + Mma_SetMode(env, DEVICE_MODE_UVEOS_GARAG); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в сервисный режим, отклонение дистанции = ") + LoggerInfo(LOGGER, LOG_SIGN, step, str_len) + Mma_GarageMode(env); + } else if (env->uveos.doNothing.mode == UVEOS_DO_NOTHING_MOVE_TO) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Переход в сервисный режим не возможен, Т.С. находится в движении, отклонение дистанции=") + LoggerInfo(LOGGER, LOG_SIGN, step, str_len) + } else if (env->uveos.doNothing.movePosition.valid == 0) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Данные GNSS не достоверны!") + } +} + +void Mma_UserInputSubstartButtonThreadStart(tMma *env) { + if (!env->threadSubstartChekButton.id) { + env->threadSubstartChekButton.id = osThreadNew( + (osThreadFunc_t) (Mma_UserInputSubstartButtonThread), + (void *) (env), + &env->threadSubstartChekButton.attr + ); + } +} + +void Mma_UserInputSubstartButtonThreadStop(tMma *env) { + if (osThreadTerminate(env->threadSubstartChekButton.id) == osOK) { + SystemDelayMs(100); + env->threadSubstartChekButton.id = NULL; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Поток предстартового опроса БИПа остановлен") + } +} + + +static _Noreturn void Mma_UserInputSubstartButtonThread(tMma *env) { + tUserInputButtonEvent buttonEvent = {0}; + bool fl_isSend = false; + while (1) { + if (fl_isSend == false) { + if (EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable) > 0) { + Mma_SetMode(env, DEVICE_MODE_UVEOS_SMS_TRANSMIT); + env->userInputSubstart = SUB_START_MODE_NOT_SEND_MSD; + } + fl_isSend = true; + } + if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) { + if (UserInputButtonEventIs(buttonEvent, UI_CUSTOM_BUTTON_TEST_MODE, FALL)) { + Mma_SetMode(env, DEVICE_MODE_TESTING); + env->userInputSubstart = SUB_START_MODE_TESTING; + } else { + if (UserInputButtonEventIs(buttonEvent, UI_CUSTOM_BUTTON_EMERGENCY, FALL)) { + Mma_SetMode(env, DEVICE_MODE_UVEOS_MANUAL_BEGIN); + env->userInputSubstart = SUB_START_MODE_EMER; + } + } + } + + SystemDelayMs(4); + } +} + + +void Mma_ClearParams(tMma *env) { + String32CopyStatic(&env->storage.nvm->gost.VIN, "00000000000000000"); +} + +void Mma_RunShortTest(tMma *env, bool blocEcall) { + eSubSystems eSubSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + SystemSelector(&env->systemSwitcher, UVEOS); + + if(blocEcall == false) { + AccompanModeStopThread(env); + } + +// GsmWithGnss_InvalidateNetworkEnable(&env->gsmWithGnss, 0, true); +// Mma_NetworkRequire(env); + + Mma_AudioSubSystemRequire(env); + + env->queryUDSState.source = SPEAK_MICR_TEST; + env->testing.audioHintsMode = HINTS_NOT_ERA_EXIT; + + SystemDelayMs(500); + Mma_RunUserTests(env, false); + SystemDelayMs(500); + +// if(blocEcall == true) { +// env->queryUDSState.source = LEDS_TEST; +// env->testing.audioHintsMode = HINTS_MINIMAL; +// Mma_RunUserTests(env, false); +// } + + env->testing.audioHintsMode = HINTS_NORMAL; + env->lastEventDevice = LAST_EVENT_TEST; + + if(blocEcall == false) { + uint16_t bufTime = env->uveos.settings->TEST_REGISTRATION_PERIOD; + uint16_t bufManDialAttems = env->uveos.settings->ECALL_MANUAL_DIAL_ATTEMPTS; + env->uveos.settings->TEST_REGISTRATION_PERIOD = 1; + env->uveos.settings->ECALL_MANUAL_DIAL_ATTEMPTS = 1; + EraGlonassUveosDumper_ForceDump(env->uveos.dumper); + Mma_AudioSubSystemRequire(env); + DeviceTesting_TestingECool(&env->testing); + env->uveos.settings->TEST_REGISTRATION_PERIOD = bufTime; + env->uveos.settings->ECALL_MANUAL_DIAL_ATTEMPTS = bufManDialAttems; + EraGlonassUveosDumper_ForceDump(env->uveos.dumper); + } + if(env->storage.nvm->device.factoryMode != true){ + DeviceTesting_ExitTestPlay(&env->testing); + } + Mma_AudioSubSystemRelease(env); + env->testing.audioHintsMode = HINTS_FULL; + SystemSelector(&env->systemSwitcher, eSubSystemsTmp); + AccompanModeStartThread(env); +} + +void Mma_PassedMode(tMma *env) { + SystemSelector(&env->systemSwitcher, UNDEFANDET); + tUserInputButtonEvent buttonEvent = {0}; + bool checStartEOL = false; + + while ((DeviceTesting_VIN(&env->storage) != DEVICE_TESTING_CODE_PASSED) || (env->eolAcsess == true)) { + + if (*env->comInt.Amplifier.playMode == true) { + Mma_AudioSubSystemRequire(env); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "test_mode.mp3", 5 * 1000); + *env->comInt.Amplifier.playMode = false; + Mma_AudioSubSystemRelease(env); + } + + Mma_SetMode(env, DEVICE_MODE_UVEOS_PASSIVE); + + if (env->tm_FactoryMessage < SystemGetMs()) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Пассивный режим, сконфигурируйте устройство!") +// if (env->fl_isFacrotyMode == true) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, +// "Устройство было в режиме производственного контроля, для отключения устройства отключите линию питания и зажигания") +// } + env->tm_FactoryMessage = SystemGetMs() + 8000; + } + + if (env->checNetDeGeg == false) { + + if (env->threadSubstartChekButton.id != NULL) { + Mma_UserInputSubstartButtonThreadStop(env); + } + env->checNetDeGeg = true; + } + + if (env->state.GsmRegistartionStateMem == 0) { + SystemSelector(&env->systemSwitcher, UVEOS); + +// if(checNetReg == false) { +// if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 4000) == osOK) { +// AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt); +// osMutexRelease(env->gsmWithGnss.gsmAt.access); +// } +// } + + checStartEOL = true; +// if( (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss,1000) == true) && (checNetReg == false) ){ +// env->state.GsmRegistartionStateMem = 2; +// env->state.GsmRegistrationState = 2; +// } +// +// if( (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss,1000) == false) && (checNetReg == false) ){ +// LoggerInfoStatic(LOGGER, LOG_SIGN, "Выполнен запрос регистрации в сети, инициализатор - процедура EOL") +// checNetReg = true; +// if(GsmWithGnss_NetworkReconnect(&env->gsmWithGnss.gsmAt , 5) == AT_OK){ +// if(GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss,2000) == true){ +// env->state.GsmRegistartionStateMem = 2; +// env->state.GsmRegistrationState = 2; +// } +// } +// +// } else if(checNetReg == true) { +// if(tm_tt > SystemGetMs()){ +// if(GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss,2000) == true){ +// LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети инициализированная EOL получена") +// env->state.GsmRegistartionStateMem = 2; +// env->state.GsmRegistrationState = 2; +// } +// tm_tt = SystemGetMs()+10000; +// } + env->state.GsmRegistartionStateMem = 2; + env->state.GsmRegistrationState = 2; +// } + } + + /** + * Проверка вызова тестирования + */ + /** НАЧАЛО **/ + /** Проверка на вызов тестирования по кнопка **/ + if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) { + if (UserInputButtonEventIs(buttonEvent, UI_CUSTOM_BUTTON_TEST_MODE, FALL)) { + UserButtons_Clear(env->testing.input); + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Получен сигнал перехода в режим пользовательского тестирования код 1") + if (checStartEOL == true) { + checStartEOL = false; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование в режиме EOL") + eSubSystems eSubSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + + SystemSelector(&env->systemSwitcher, UVEOS); + + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_ACTIVE + ); + + env->testing.audioHintsMode = HINTS_NORMAL; + Mma_RunShortTest(env, false); + env->testing.audioHintsMode = HINTS_FULL; + + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_NOT_ACTIVE + ); + + EraGlonassMsdTable_Init(env->uveos.msdTable); + EraGlonassUveosDumper_ForceDump(env->uveos.dumper); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Данные о экстренных вызовах очищены из ПЗУ устройства") + + if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 2000) == true) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети инициализированная EOL получена") + env->state.GsmRegistartionStateMem = 2; + env->state.GsmRegistrationState = 2; + } + + SystemSelector(&env->systemSwitcher, eSubSystemsTmp); + + env->state.GsmRegistartionStateMem = 0; + env->eolAcsess = false; + + + } else { + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_ACTIVE + ); + + Mma_RunShortTest(env, false); + + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_NOT_ACTIVE + ); + } + env->userInputSubstart = SUB_START_MODE_UNDEF; + UserButtons_Clear(env->testing.input); + } + } + /** Иначе очищаем полученные события нажатий и проверяем + * флаг предстартовой проверки событий на вызов тестирования по кнопкам + */ + else { + UserButtons_Clear(env->testing.input); + if (env->userInputSubstart == SUB_START_MODE_TESTING) { + env->userInputSubstart = SUB_START_MODE_UNDEF; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование в режиме EOL 2") + if (checStartEOL == true) { + checStartEOL = false; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование в режиме EOL 3") + eSubSystems eSubSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + + SystemSelector(&env->systemSwitcher, UVEOS); + + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_ACTIVE + ); + + env->testing.audioHintsMode = HINTS_NORMAL; + Mma_RunShortTest(env, false); + env->testing.audioHintsMode = HINTS_FULL; + + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_NOT_ACTIVE + ); + + EraGlonassMsdTable_Init(env->uveos.msdTable); + EraGlonassUveosDumper_ForceDump(env->uveos.dumper); +// LoggerInfoStatic(LOGGER, LOG_SIGN, "Данные о экстренных вызовах очищены из ПЗУ устройства") + + if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 2000) == true) { +// LoggerInfoStatic(LOGGER, LOG_SIGN, "Регистрация в сети инициализированная EOL получена") + env->state.GsmRegistartionStateMem = 2; + env->state.GsmRegistrationState = 2; + } + + SystemSelector(&env->systemSwitcher, eSubSystemsTmp); + + env->state.GsmRegistartionStateMem = 0; + env->eolAcsess = false; + } else { + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_ACTIVE + ); + + Mma_RunShortTest(env, false); + + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_NOT_ACTIVE + ); + } + } + } + /** + * Проверка вызова тестирования + */ + /** КОНЕЦ **/ + + Mma_RunTests(env); + + if (checStartEOL == false) { + Mma_SubstartTelematica(env); + } + + /** + * Проверка отключения для производственного контроля или после выхода из него + * Если зажигание отключено и + * Напряжение сети меньше 7 Вольт + * Переходим к процедуре отключения + */ + if (env->fl_isFacrotyMode == true) { + if ( + (GpioPinGet(&env->power.powerSusystem->main.ignition) == false) && + (env->power.powerSusystem->boardPower.currentBoardVoltage < 7000) + ) { + Mma_Shutdown(env); + } + } + + /** + * Если мы не в режиме производственного контроля + * и не были в нем в текущем включении + * Осуществляется стандартная проверка отключения + */ + if ((env->fl_isFacrotyMode != true) /* && (checStartEOL == false) */) { + Mma_CheckShutdown(env); + } + SystemDelayMs(100); + + } +} + + +void setGeneralGNSS(tMma *env, + eCanGnssCallByButton GNSS_Call_By_button, + eCanGnssStatus GNSS_Status, + eCanGnssCallAuto GNSS_Call_Auto, + eCanGnssCallTest GNSS_Call_Test + ) { + if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) { + env->GNSS_General.GNSS_Call_By_button = GNSS_Call_By_button; + env->GNSS_General.GNSS_Status = GNSS_Status; + env->GNSS_General.GNSS_Call_Auto = GNSS_Call_Auto; + env->GNSS_General.GNSS_Call_Test = GNSS_Call_Test; + } +} + + +static _Noreturn void Mma_Thread(tMma *env) { + env->tmStart = SystemGetMs(); + uint32_t bufTm = 0; + //Запуск устройства + Mma_InitStage(env); + AccompanModeStartThread(env); + size_t size = xPortGetMinimumEverFreeHeapSize(); + uint32_t sizeStorage = sizeof(tDeviceDataNonVolatile); + LoggerStrFormatInfo(LOGGER, LOG_SIGN, "Свободно %u байт в куче. Размер хранилища %u", size, sizeStorage) + + tDeviceModes *indicationState = UserIndication_GetMode(env); + tUserInputButtonEvent buttonEvent = {0}; + tUveosEmergencyEvent emergencyEvent = {0}; + + while (env->storage.nvm->device.factoryMode) { + SystemDelayMs(100); + } + + if (env->storage.nvm->device.serviseMode) { + Mma_UserInputSubstartButtonThreadStop(env); + Mma_RunServiceMode(env); + Mma_UserInputSubstartButtonThreadStart(env); + } + + if (!env->storage.nvm->device.factoryMode) { + Mma_PassedMode(env); + env->userInputSubstart = SUB_START_MODE_UNDEF; + UserButtons_Clear(env->testing.input); + Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_WAIT_GNSS); + EraGlonassUveosDumper_ForceDump(env->uveos.dumper); + } + + uint32_t noSendMsdCount = EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable); + if (env->storage.nvm->gost.notGost.ECALL_DEBUG_MODE) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "ДОСТУП ЗАБЛОКИРОВАН, СИСТЕМА В РЕЖИМЕ ОТЛАДКИ") + noSendMsdCount = 0; + } + + if ( + (noSendMsdCount > 0) && + (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) + ) { + LoggerTraceStatic(LOGGER, LOG_SIGN, "Обнаружены не обработанные МНД, инициализирована процедура переотправки") + SystemSelector(&env->systemSwitcher, UVEOS); + + uint32_t tm_t = SystemGetMs() + 10000; + while ((env->fl_iniSysIsDone != true) && (tm_t > SystemGetMs())) { + LoggerTraceStatic(LOGGER, LOG_SIGN, + "Обнаружены не обработанные МНД, ожидание инициализации системы для дальнейшей их обработки") + SystemDelayMs(2000); + } + + uint8_t bufUserInputSubstart = env->userInputSubstart; + eSubSystems eSubSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + + if (GsmWithGnss_NetworkSetStateInnaterups(&env->gsmWithGnss, 4, 40) == AT_OK) { + + LoggerTraceStatic(LOGGER, LOG_SIGN, "Регистрация в сети выполнена") + AccompanModeStopThread(env); + EraGlonassUveos_ProcessingEra(&env->uveos); + AccompanModeStartThread(env); + + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС") + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_NetworkSetStateInnaterups 0") + } + + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss.gsmAt); + LoggerTraceStatic(LOGGER, LOG_SIGN, "Регистрация в сети отключена") + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_NetworkSetStateInnaterups 1") + } + + noSendMsdCount = EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable); + if (noSendMsdCount == 0) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Не отправленные экстренные события обработаны полностью, данные из ПЗУ очищены") + EraGlonassMsdTable_Init(env->uveos.msdTable); + EraGlonassUveosDumper_ForceDump(env->uveos.dumper); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Остались не обработанные МНД в хранилище") + } + + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует") + } + + ModemDataCollector_SetThisSubSystem(&env->systemSelector, eSubSystemsTmp); + env->userInputSubstart = bufUserInputSubstart; + osMutexRelease(env->mux_factoryMode); + } + + Mma_UserInputSubstartButtonThreadStop(env); + + if (env->userInputSubstart == SUB_START_MODE_EMER) { + env->userInputSubstart = SUB_START_MODE_UNDEF; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Экстренный вызов, предстартовый поток") + Mma_EcallManual(env); + } else { + if (env->userInputSubstart == SUB_START_MODE_TESTING) { + env->userInputSubstart = SUB_START_MODE_UNDEF; + env->testing.queryUDSState->state = QUERY_BUSY; + env->queryUDSState.source = FULL_TESTS; + AccompanModeStopThread(env); + Mma_RunUserTests(env, true); + AccompanModeStopThread(env); + env->testing.queryUDSState->state = QUERY_STOP; + } + } + + if (env->storage.nvm->gost.notGost.ECALL_DEBUG_MODE) { + SystemSelector(&env->systemSwitcher, UVEOS); + + Mma_AudioSubSystemRequire(env); + } + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск главного цикла") + + for (;;) { + + Mma_SubstartTelematica(env); + + while (env->storage.nvm->device.factoryMode) { + SystemDelayMs(1000); + } + + Mma_UserInputSubstartButtonThreadStop(env); + + AccompanModeStartThread(env); + Mma_SetMode(env, *indicationState); + LoggerTraceStatic(LOGGER, LOG_SIGN, "Обновляем индикацию") + + Mma_CheckingChangesGNSS_Antena(env); + + if ((env->uveos.timings.lastInMemTransmit < SystemGetMs()) && (env->uveos.settings->notGost.ECALL_DEBUG_MODE)) { + if (bufTm < SystemGetMs()) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Периодическая проверка необходимости повторной отправки МНД НЕ ВЫПОЛНЕНА, СИСТЕМА В ДЭБАГ РЕЖИМЕ") + bufTm = SystemGetMs() + 4000; + } + } + + if ((env->uveos.timings.lastInMemTransmit < SystemGetMs()) && + (!env->uveos.settings->notGost.ECALL_DEBUG_MODE)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Периодическая проверка необходимости повторной отправки МНД") + + noSendMsdCount = EraGlonassMsdTable_GetNoSendDataCount(env->uveos.msdTable); + if (env->storage.nvm->gost.notGost.ECALL_DEBUG_MODE) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "ДОСТУП ЗАБЛОКИРОВАН, СИСТЕМА В РЕЖИМЕ ОТЛАДКИ") + noSendMsdCount = 0; + } + + if ((noSendMsdCount > 0) && (osMutexAcquire(env->mux_factoryMode, 5000) == osOK)) { + eSubSystems subSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + + if (subSystemsTmp != UVEOS) { + SystemSelector(&env->systemSwitcher, UVEOS); + + } + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Обнаружены не обработанные МНД, проверка регистрации в сети") + if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss, 2000)) { + AccompanModeStopThread(env); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть присутствует") + LoggerTraceStatic(LOGGER, LOG_SIGN, + "Производится обработка не переданных МНД, передача по средствам PDU пакетов") + EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС") + + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt); + SystemDelayMs(500); + AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено") + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } + + AccompanModeStartThread(env); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует, попытка регистрации код 3") + if (GsmWithGnss_NetworkSetStateInnaterups(&env->gsmWithGnss, 5, 5000) == AT_OK) { + LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть присутствует") + LoggerTraceStatic(LOGGER, LOG_SIGN, + "Производится обработка не переданных МНД, передача по средствам PDU пакетов") + EraGlonassUveos_ProcessingCheckNoSendMSD(&env->uveos); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление всех СМС") + + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt); + SystemDelayMs(500); + AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено") + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } + + SystemDelayMs(500); + + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt); + SystemDelayMs(500); + AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено") + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Удаление СМС выполнено") + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Периодическая проверка необходимости повторной отправки МНД не выполнена, сеть отсутствует") + } + } + + LoggerTraceStatic(LOGGER, LOG_SIGN, "Обработка не отправленных МНД выполнена") + SystemSelector(&env->systemSwitcher, subSystemsTmp); + + osMutexRelease(env->mux_factoryMode); + } + + env->uveos.timings.lastInMemTransmit = + SystemGetMs() + (env->uveos.settings->INT_MEM_TRANSMIT_INTERVAL * 60 * 1000); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Время периодическая проверки повторной отправки МНД обновлено") + } + + if (UveosEmergencyEvent_GetNext(&env->crashDetect.emergencyEvents, &emergencyEvent, 0)) { + if (env->storage.nvm->gost.CRASH_SIGNAL_INTERNAL == 1) { + if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) { + + if (env->crashDetect.carCrashDetection.asi15.impactDetected) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Тип события - столкновение") + env->lastEventDevice = LAST_EVENT_IMPACT; + } + if (env->crashDetect.carCrashDetection.flip.flipDetected) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Тип события - переворот") + env->lastEventDevice = LAST_EVENT_FLIP; + } + + Mma_EcallAutomatic(env, emergencyEvent); + Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY); + osMutexRelease(env->mux_factoryMode); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата Mma_EcallAutomatic") + } + } + } + + if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) { + if (UserInputButtonEventIs(buttonEvent, UI_CUSTOM_BUTTON_TEST_MODE, FALL)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Получен сигнал перехода в режим пользовательского тестирования код 3") + + if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) { +#if (AURUS_CAR_UI == 1) + LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование") + bool fl_audioHids = env->uveos.fl_audioHids; + env->uveos.fl_audioHids = false; + + env->testing.queryUDSState->state = QUERY_BUSY; + env->queryUDSState.source = INTERNAL_ONE_TEST; + env->lastEventDevice = LAST_EVENT_TEST; + Mma_RunUserTests(env,true); + osMutexRelease(env->mux_factoryMode); + env->testing.queryUDSState->state = QUERY_STOP; + env->uveos.fl_audioHids = fl_audioHids; +#endif +#if (AURUS_CAR_UI == 0) + LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов режима пользовательского тестирование") + env->testing.queryUDSState->state = QUERY_BUSY; + env->queryUDSState.source = FULL_TESTS; + env->lastEventDevice = LAST_EVENT_TEST; + AccompanModeStopThread(env); + Mma_RunUserTests(env,true); + AccompanModeStartThread(env); + osMutexRelease(env->mux_factoryMode); + env->testing.queryUDSState->state = QUERY_STOP; +#endif + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата ( Mma_RunUserTests )") + } + } + + if (UserInputButtonEventIs(buttonEvent, UI_CUSTOM_BUTTON_EMERGENCY, FALL)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Нажата кнопка экстренного вызова") + if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) { + env->lastEventDevice = LAST_EVENT_MANUAL; + //начало-----------------Обновление счетчиков телематики (для отладки)-------------------------------------- + if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) { + EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_COUNTER_2); + } + //конец------------------Обновление счетчиков телематики (для отладки)-------------------------------------- + Mma_EcallManual(env); + osMutexRelease(env->mux_factoryMode); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата Mma_EcallManual") + } + } else if (UserInputButtonEventIsBetween(buttonEvent, UI_VIRT_BUTTON_ADDITIONAL, RAISE, SERVICE_MODE_MIN, SERVICE_MODE_MAX)) { + if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов сервисного режима ") + Mma_RunServiceMode(env); + osMutexRelease(env->mux_factoryMode); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата Mma_RunServiceMode") + } + } + } + + if (env->fl_iniSysIsDone == true) { + if ((EraGlonassUveos_IsAllowInCall(&env->uveos) == true) && (env->gsmWithGnss.urc.ring)) { + if (GsmWithGnss_isInpCallActive(&env->gsmWithGnss)) { + if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) { + Mma_ProcessCallAnswer(env); + env->gsmWithGnss.urc.ring = false; + osMutexRelease(env->mux_factoryMode); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата Mma_ProcessCallAnswer 1") + } + } + } + if ((EraGlonassUveos_IsAllowInCall(&env->uveos) == false) && (env->gsmWithGnss.urc.ring)) { + if (osMutexAcquire(env->mux_factoryMode, 5000) == osOK) { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Была попытка дозвона на устройство с завершённым таймером ожидания входящего вызова") + AtGsmHangUpCall(&env->gsmWithGnss.gsmAt); + env->gsmWithGnss.urc.ring = false; + LoggerInfoStatic(LOGGER, LOG_SIGN, "Попытка дозвона прекращена принудительно") + osMutexRelease(env->mux_factoryMode); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата Mma_ProcessCallAnswer 2") + } + } + } + + eSubSystems subSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + if (subSystemsTmp == UVEOS) { + if (EraGlonassUveos_IsRequireNetwork(&env->uveos)) { + Mma_SetNetworkRegistration(env, true); + } else { + Mma_SetNetworkRegistration(env, false); + } + } + + if (subSystemsTmp == UVEOS) { + if (Mma_CheckIncomingSms(env) == AT_TIMEOUT) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Проведена проверка входящих PDU пакетов") + } + } +// Mma_Shutdown(env); + Mma_CheckShutdown(env); + Mma_RunTests(env); + + SystemDelayMs(40); + } +} + +void Mma_StartThread(tMma *env) { + if (!env->thread.id) { + env->thread.id = osThreadNew((osThreadFunc_t) (Mma_Thread), (void *) (env), &env->thread.attr); + } else { + osThreadResume(env->thread.id); + } +} diff --git a/MainModesArbiter.h b/MainModesArbiter.h new file mode 100644 index 0000000..576ede3 --- /dev/null +++ b/MainModesArbiter.h @@ -0,0 +1,188 @@ +// +// Created by xemon on 19.09.22. +// + +#ifndef SMART_COMPONENTS_MAINMODESARBITER_H +#define SMART_COMPONENTS_MAINMODESARBITER_H + +#include +#include "I2cPorts.h" +#include "Rtcs.h" +#include "Gpios.h" +#include "SerialPorts.h" +#include "Adcs.h" +#include "StorageOnFlash.h" +#include "FreeRTOS.h" +#include "DeviceStorage.h" +#include "AudioCodec.h" +#include "GsmWithGnss.h" +#include "Accel.h" +#include "LoggerToSerialPort.h" +#include "CrashDetection.h" +#include "ComInt.h" +#include "ComandLineInterface.h" +#include "DeviceTesting_Env.h" +#include "SignaturePduSpecific.h" +#include "Amplifier.h" +#include +#include +#include "CanPorts.h" +#include "ext_telematica.h" +#include "AudioPlayerSimComSim7600E.h" +#include "AudioRecorderSimComSim7600E.h" +#include "ModemDataCollector.h" +#include "TelematicaConnectStatus.h" +#include "SubsystemSwitcher.h" + +typedef struct { + + // Преферийные интерфесы + tGpios *gpios; + tSerialPorts *serialPorts; + tI2cPorts *i2cPorts; + tSpiPorts *spiPorts; + tAdcs *adcs; + tStorageOnFlash *flash; + tRtcs *rtc; + tCanPorts *canPorts; + + // Преферийные устройства + tDeviceStorage storage; + tPowerManagement power; + tAudioCodec audioCodec; + tAmplifier amplifier; + tGsmWithGnss gsmWithGnss; + tAccel *accel; + tAudioPlayer audioPlayer; + tAudioRecorder audioRecorder; + //Подсистемы + tLoggerToSerialPort slog; + tUserInput userInput; + tUserIndication indication; + tComInt comInt; +// tCli cli; + tCli cliVrt; + tModemDataColl ModemDataCollector; + tDeviceTesting testing; + + tCrashDetection crashDetect; + tEraGlonassUveos uveos; + tSystemSelector systemSelector; + uint32_t lastSmsCheckTime; + + struct { + osThreadId_t id; + uint32_t stack[4048]; //4048 6072 + StaticTask_t controlBlock; + osThreadAttr_t attr; + } thread; + + tSystemStateID_0006 SystemStateID_0006; + tInputStatesRecord_0001 InputStatesRecord_0001; + tOutputStatesRecord_0002 OutputStatesRecord_0002; + + struct { + uint8_t BoardVoltage; + uint8_t ReserveBatteryCharge; + uint8_t ReserveBatteryTemperature; + tVehicleCoordinates VehicleCoordinates; + uint8_t VehicleCoordinatesReliability; + uint8_t MDS_FormatVersion; + uint8_t TCM_working_mode; + uint8_t TCM_activation_source; + uint8_t TCM_time_calculation; + uint8_t GLONASS_and_GLONASS_GPS_groups; + uint8_t GsmRegistrationState; + uint32_t TimeStamp; + uint8_t GsmInnerError; + uint8_t VehicleCoordinatesReliabilityMem; + uint8_t GsmRegistartionStateMem; + uint8_t GsmRegistrationError; + uint8_t EcallOn; + uint8_t CrashSignalExternal; + uint16_t GnssPowerOffTime; + uint8_t AutomaticActivationProhibition; + uint8_t ECALLToTest; + uint8_t NadRegistrationAtStartup; + char GSMSoftwareVersionNumber[32]; // 20 + char SmsFallbackTestNumber[20]; // 20 + uint8_t SimProfileAmount; + uint8_t SimProfile; + uint8_t AudioProfile; + uint8_t EcallNoAutomaticTriggering; + uint8_t MiddletState; + char Vehicle_SW_Version[3]; // 3 + char Midlet_SW_Version[3]; // 3 + char Boot_SW_Version[27]; // 27 + uint8_t SertState; + uint16_t ApplicationCheckSum; + uint8_t Audio_HW_Settings; + tEmergencyCallCounter ECALL_EmergencyCallCounter; + char Avaialble_Networks_List[128]; //128 + uint8_t SavedMSDAmount; + uint8_t SentMSDAmount; + char VehicleManufacturerSparePartNumber[10]; //10 + char ConfigurationFileReferenceLink[10]; //10 + char SystemSupplierIdentifier[3]; //3 + char ECUSerialNumber[20]; //20 + char VehicleManufacturerECUHardwareNumber[10]; //10 + char SystemSupplierECUSoftwareNumber[2]; //2 + char SystemSupplierECUSoftwareVersionNumber[2]; //2 + uint8_t VDIAG; + } state; + + bool flIgn; + bool playMode; + bool fl_iniSysIsDone; + + tStaticThreadBlock(128) threadSubstartChekButton; + tStaticThreadBlock(512) threadAccompanMode; + tStaticThreadBlock(512) threadToUDS_Info; + + tSignPack signature; + uint8_t userInputSubstart; + eQueryUDSState queryUDSState; + osMutexId_t mux_factoryMode; + uint32_t tmt; + uint32_t tmpTm; + uint32_t tm_FactoryMessage; + bool checNetDeGeg; + + /** + * Флаг очистки переменных EOL + */ + bool eolAcsess; + + /** + * Флаг проверки нахождения в режиме производственного теста + */ + bool fl_isFacrotyMode; + + + eTelematicaIsConnect telematicaIsConnect; + tGNSS_General GNSS_General; + eLastEventDevice lastEventDevice; + eCarType carType; + uint32_t tmStart; + tSystemSwitcher systemSwitcher; +} tMma; + +void Mma_Init( + tMma *env, + tGpios *gpios, + tSerialPorts *serialPorts, + tI2cPorts *i2cPorts, + tSpiPorts *spiPorts, + tAdcs *adcs, + tStorageOnFlash *flash, + tRtcs *rtc, + tCanPorts *canPorts +); + +void Mma_StartThread(tMma *env); + +void AccompanModeStopThread(tMma *env); + +#define Mma_SetMode(ENV, VALUE) UserIndication_SetMode(&((ENV)->indication),(VALUE)) + +#endif //SMART_COMPONENTS_MAINMODESARBITER_H diff --git a/MainModesArbiter_Ecalls.c b/MainModesArbiter_Ecalls.c new file mode 100644 index 0000000..c24627d --- /dev/null +++ b/MainModesArbiter_Ecalls.c @@ -0,0 +1,239 @@ +// +// Created by zemon on 18.10.24. +// + + +#include "MainModesArbiter_Private.h" +#include "PointEvent.h" + +#define LOG_SIGN "Главн." +#define LOGGER &env->slog.logger + +void Mma_ProcessCallAnswer(tMma *env) { + env->testing.queryUDSState->state = QUERY_BUSY; + + eSubSystems subSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + if(subSystemsTmp != UVEOS) { + SystemSelector(&env->systemSwitcher, UVEOS); + } + LoggerInfoStatic(LOGGER, LOG_SIGN, "Получен вызов от оператора"); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Включение аудио подсистемы"); + Mma_AudioSubSystemStart(&env->power, &env->amplifier); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Включение линии ecall в бортовой сети ТС"); + GpioPinEnable(&env->power.powerSusystem->main.ecallOut); + + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "audio_on.mp3", 4*1000); + + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + AtGsmAnswer(&env->gsmWithGnss.gsmAt); + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления AtGsmAnswer") + } + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов от оператора принят"); + env->uveos.currentMsd->msd.MSD_Data.msgId = 1; + Mma_SetMode(env, DEVICE_MODE_UVEOS_IN_CALL); + while (GsmWithGnss_isInpCallActive(&env->gsmWithGnss)) { + env->uveos.fl_ecallState = true; + SystemDelayMs(500); + } + LoggerInfoStatic(LOGGER, LOG_SIGN, "Вызов от оператора завершён"); + + AtCommandResult res = AtGsmHangUpCall(&env->gsmWithGnss.gsmAt); + while (res != AT_OK) { + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + res = AtGsmHangUpCall(&env->gsmWithGnss.gsmAt); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Освобождение управления 21"); + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления AtGsmHangUpCall") + } + LoggerInfoStatic(LOGGER, LOG_SIGN, "Поднят HangUp"); + + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + GsmWithGnss_resetInputCall(&env->gsmWithGnss); + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления GsmWithGnss_resetInputCall") + } + LoggerInfoStatic(LOGGER, LOG_SIGN, "Выполнен сброс Ринга"); + + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "era_mode.mp3", 4*1000); + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Питание УНЧ отключено"); + Mma_AudioSubSystemRelease(env); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сигнал MUTE отключен от бортовой сети "); + Pwm_SetMuteInCar(&env->power, false); + GpioPinDisable(&env->power.powerSusystem->main.ecallOut); + env->uveos.fl_ecallState = false; + env->testing.queryUDSState->state = QUERY_STOP; + Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY); + return; + } +} + +void Mma_ReleaseEcallSubSystems(tMma *env) { + GpioPinDisable(&env->power.powerSusystem->main.ecallOut); + EraGlonassEcallProvider_HangupEcl(env->uveos.ecallProvider); + + StopResiver(&env->gsmWithGnss); + HotStartGNSS(&env->gsmWithGnss); + + GpioPinDisable(&env->power.powerSusystem->main.ecallOut); + +#if (AURUS_CAR_UI == 1) + AudioPlayer_PlayStaticTone(env->uveos.audioPlayerIO,1); +#endif +#if (AURUS_CAR_UI == 0) + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "era_mode.mp3", 4 * 1000); +#endif + + EraGlonassUveos_SetTimings(&env->uveos); + SystemDelayMs(4000); + + Mma_AudioSubSystemRelease(env); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Обработка экстренной ситуации завершена") +} + +void Mma_EcallManual(tMma *env) { + ///* fix GNSS_General + AccompanModeStopThread(env); + EraGlonassUveos_SetTimings(&env->uveos); + env->testing.queryUDSState->state = QUERY_BUSY; + + setGeneralGNSS(env, + CAN_GNSS_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_NOT_ACTIVE + ); + + env->uveos.fl_ecallState = true; + Mma_SetMode(env, DEVICE_MODE_UVEOS_MANUAL_BEGIN); + Mma_AudioSubSystemRequire(env); + +#if (AURUS_CAR_UI == 1) + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "emerCool_aurus.mp3", 5*1000); +#endif +#if (AURUS_CAR_UI == 0) + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "ecall_on.mp3", 5*1000); +#endif + + if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) { + eEgtsEventTetedata egtsEventTetedata = EVENT_USER_CALL; + EXT_ENV_ADR_TELE.tele_func(&egtsEventTetedata, TELE_MODULE_ADD_EVENT); + } + + SystemSelector(&env->systemSwitcher, UVEOS); + + eSubSystems subSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + if(subSystemsTmp != UVEOS) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "ОШИБКА ВЫПОЛНЕНИЯ ПРОЦЕДУРЫ ЭКСТРЕННОГО ВЫЗОВА"); + if(env->ModemDataCollector.modemVersionRevision.valid_CCID != MOD_READY) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "ОШИБКА СИМ ЧИПА"); + return; + } + } + + Mma_NetworkRequire(env); + GpioPinEnable(&env->power.powerSusystem->main.ecallOut); + + env->uveos.currentMsd->msd.MSD_Data.msgId = 1; + + /// Очистка нажатий перед началом ECALL + /// для избежания случайной отмены вызова + UserButtons_Clear(&env->userInput.buttonsInterface); + + eEraGlonassUveos_EcallProcessingResult res = EraGlonassUveos_ManualEmergencyCall(&env->uveos); + + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + GsmWithGnss_ResetRing(&env->gsmWithGnss); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сброс URC RING выполнен 2"); + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления, сброс URC RING 2") + } + + env->uveos.fl_ecallState = false; + Mma_ReleaseEcallSubSystems(env); + + /// Очистка нажатий после ECALL + /// для избежания случайного вызова + UserButtons_Clear(&env->userInput.buttonsInterface); + + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_NOT_ACTIVE + ); + + env->testing.queryUDSState->state = QUERY_STOP; + Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY); + AccompanModeStartThread(env); +} + +void Mma_EcallAutomatic(tMma *env, tUveosEmergencyEvent emergencyEvent) { + AccompanModeStopThread(env); + EraGlonassUveos_SetTimings(&env->uveos); + env->testing.queryUDSState->state = QUERY_BUSY; + + if(emergencyEvent.isFlip) { + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_NOT_ACTIVE + ); + } else { + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_NOT_ACTIVE + ); + } + + env->uveos.fl_ecallState = true; + Mma_SetMode(env, DEVICE_MODE_UVEOS_AUTOMATIC_BEGIN); + Mma_AudioSubSystemRequire(env); + AudioPlayer_PlayToWait(env->uveos.audioPlayerIO, "ecall_on.mp3", 5*1000); + + if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) { + eEgtsEventTetedata egtsEventTetedata = EVENT_EMERGENCY_CALL; + EXT_ENV_ADR_TELE.tele_func(&egtsEventTetedata, TELE_MODULE_ADD_EVENT); + if(emergencyEvent.isFlip){ + EXT_ENV_ADR_TELE.tele_func(NULL, TELE_MODULE_FUEL_CUT_OFF); + } + } + + SystemSelector(&env->systemSwitcher, UVEOS); + + Mma_NetworkRequire(env); + GpioPinEnable(&env->power.powerSusystem->main.ecallOut); + + eEraGlonassUveos_EcallProcessingResult res = EraGlonassUveos_ProcessingEmergencyEvent(&env->uveos, &emergencyEvent); + + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + GsmWithGnss_ResetRing(&env->gsmWithGnss); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сброс URC RING выполнен 3"); + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления, сброс URC RING 3") + } + + Mma_ReleaseEcallSubSystems(env); + env->uveos.fl_ecallState = false; + + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_NO_MALFUNCTIONS, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_NOT_ACTIVE + ); + + env->testing.queryUDSState->state = QUERY_STOP; + Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_GNSS_READY); + AccompanModeStartThread(env); +} \ No newline at end of file diff --git a/MainModesArbiter_EgtsSms.c b/MainModesArbiter_EgtsSms.c new file mode 100644 index 0000000..3040a02 --- /dev/null +++ b/MainModesArbiter_EgtsSms.c @@ -0,0 +1,76 @@ +// +// Created by xemon on 09.01.23. +// + + +#include "MainModesArbiter_Private.h" +#include + +#define LOG_SIGN "Главн. sms" +#define LOGGER &env->slog.logger + +void Mma_DeletSms(tMma *env) { + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 1000) == osOK) { + AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt); + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } +} + +AtCommandResult Mma_CheckIncomingSms(tMma *env) { + + if (env->lastSmsCheckTime > SystemGetMs()) { + return AT_NONE; + } + env->lastSmsCheckTime = SystemGetMs() + 8000; + + uint8_t binaryData[255]; + memset(binaryData, 0, sizeof(binaryData)); + uint16_t binaryDataSize = 0; + + AtCommandResult resultReadPdu = AtGsmSms_UtilsReadPduData(&env->gsmWithGnss.gsmAt, binaryData, &binaryDataSize, sizeof(binaryData)); + if (resultReadPdu == AT_OK) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Получена команда посредствам СМС"); + if (binaryDataSize) { + eSubSystems subSystemsTmp = ModemDataCollector_GetThisSubSystem(&env->systemSelector); + SystemSelector(&env->systemSwitcher, UVEOS); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Команда содержит EGTS пакет"); + Mma_AudioSubSystemRequire(env); + Mma_NetworkRequire(env); + + bool res = EraGlonassUveos_ProcessEgtsPacket(&env->uveos, &env->storage, binaryData, binaryDataSize); + + if( + (env->indication.mode == DEVICE_MODE_UVEOS_ERA_WAIT_GNSS) || + (env->indication.mode == DEVICE_MODE_UVEOS_ERA_GNSS_READY) + ){ + Mma_AudioSubSystemRelease(env); + } + + if(res == true) { + StopResiver(&env->gsmWithGnss); + HotStartGNSS(&env->gsmWithGnss); + } + SystemSelector(&env->systemSwitcher, subSystemsTmp); + + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Команда не содержит EGTS пакета"); + } + + uint32_t t = SystemGetMs() + 2000; + while (t > SystemGetMs()){ + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 100) == osOK) { + if(AtGsmSms_DeleteAll(&env->gsmWithGnss.gsmAt) == AT_OK){ + osMutexRelease(env->gsmWithGnss.gsmAt.access); + return AT_OK; + } + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } + SystemDelayMs(40); + } + return AT_TIMEOUT; + } else { + return resultReadPdu; + } + return resultReadPdu; +} + diff --git a/MainModesArbiter_InitStage.c b/MainModesArbiter_InitStage.c new file mode 100644 index 0000000..1686dbb --- /dev/null +++ b/MainModesArbiter_InitStage.c @@ -0,0 +1,1143 @@ +// +// Created by xemon on 11.12.22. +// + +//AT+CGMR +// uint8_t packet[] = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; +// env->signature.atCmd = &env->gsmWithGnss.gsmAt; +// env->signature.slog = &env->slog; +// while (1){ +// EraTSK_GetPackSignature(&env->signature,packet,sizeof(packet)); +// SystemDelayMs(1000000); +// // SystemDelayMs(1); +// } + +#include "MainModesArbiter_Private.h" +//#include "FirmwareMetadataSection.h" +#include "FirmwareUveosMetadataSection.h" +#include "DeviceTesting.h" +#include "AtCmdCommonProtected.h" +#include "Amplifier.h" +#include "stdlib.h" +#include "ld_adr.h" +#include "AudioPlayerSimComSim7600E.h" +#include "math.h" +#include "DeviceTesting_TestsWithUser.h" +#include "BootJump.h" + +#define LOG_SIGN "Главн. Вкл" +#define LOGGER &env->slog.logger + +static void Mma_InitSubSystems(tMma *env); + +static void Mma_PreInitSubSystems(tMma *env); + +static void Mma_InitAndRunIndication(tMma *env); + +static void Mma_InitPower(tMma *env); + +static void Mma_InitComInt( + tMma *env, + tString16 *deviceId, + tVariablesTable *varsTab +) { + env->playMode = false; + tSerialPortIO *thisComPortIO; + tSerialPortIO *thisCanComPortIO = NULL; + + thisComPortIO = &env->serialPorts->Rs485_HalfDuplexIo; + + if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) { + thisCanComPortIO = EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_GET_CAN_COM_IO); + } + + ComInt_Init( + &env->comInt, + thisComPortIO, + thisCanComPortIO, + deviceId, + varsTab, + &env->testing.testsTable, + &env->serialPorts->Modem_snif_IO, + &env->serialPorts->cliVirtualOutIo, + NULL, + &env->indication.currentModeName, + &env->crashDetect.carCrashDetection.flip, + &env->amplifier, + &env->audioCodec, + &env->testing, + &env->power, + &env->playMode, + &env->systemSelector.thisSsubSystem, + &env->storage.nvm->device.telematicaIsActive, + &env->storage.runtime.telematicaServerIsActive, + &env->storage.nvm->device.factoryMode + ); +} + +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); + } + } +} + +_Noreturn void Mma_FatalErrorOnInit(tMma *env, bool noinit, tDeviceModes errState) { + tString16 alertId = {0}; + + if (noinit) { + Mma_InitPower(env); + Mma_InitAndRunIndication(env); + String16CopyStatic(&alertId, "MEMERR"); + Mma_InitComInt(env, &alertId, NULL); + ComInt_StartThread(&env->comInt); + } + + Mma_SetMode(env, errState); + + env->SystemStateID_0006.TCM_State = 0; + env->fl_iniSysIsDone = true; + if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) { + ///* переключение в режим телематики + SystemSelector(&env->systemSwitcher, TELEMATICA); + EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_START); + } + + for (;;) { + Mma_CheckShutdown(env); + SystemDelayMs(6000); + } +} + +void Mma_InitAudioSubsystem(tMma *env) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация аудио подсистем...") + + AudioCodec_Init(&env->audioCodec, + &env->i2cPorts->codecI2c3_IO, + NULL, + NULL, + &env->storage.uveosDumper, + &env->carType + ); + + Amplifier_Init( + &env->amplifier, + &env->i2cPorts->amplI2c2_IO, + &env->storage.uveosDumper, + &env->storage.nvm->gost.notGost.AMPL_CONF, + &env->power, + &env->power.powerSusystem->SpekTestPower.speakTestAcsess + ); + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация аудио подсистем выполнена") +} + +static void Mma_InitPeripheralDevices(tMma *env) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация устройств...") + + AtCmdInit( + &env->gsmWithGnss.gsmAt, &env->serialPorts->Modem_IO, + env->gsmWithGnss.mem.gsmTx, sizeof(env->gsmWithGnss.mem.gsmTx), + env->gsmWithGnss.mem.gsmRx, sizeof(env->gsmWithGnss.mem.gsmRx), + 2000, 2000 + ); + + AudioPlayerSimComSim7600E_Init(&env->audioPlayer, &env->gsmWithGnss.gsmAt); + AudioRecordSimComSim7600E_Init(&env->audioRecorder, &env->gsmWithGnss.gsmAt); + + GsmWithGnssInit( + &env->gsmWithGnss, + &env->storage.nvm->device.smsServiceCenter, + &env->storage.nvm->gost.GNSS_DATA_RATE, + &env->rtc->rtcI0, + &env->storage.runtime.enableGnssUpdate, + &env->audioPlayer, + &env->audioRecorder + ); + + env->gsmWithGnss.logger = &env->slog.logger; + env->gsmWithGnss.ecallProvider.smsEnv = env; + env->gsmWithGnss.ecallProvider.delSms = (void *) Mma_DeletSms; + env->gsmWithGnss.ecallProvider.checkSms = (void *) Mma_CheckIncomingSms; + env->gsmWithGnss.ecallProvider.isNetworkState = (void *) GsmWithGnss_WaitNetworkRegistration; + env->gsmWithGnss.ecallProvider.isNetworkReg = (void *) GsmWithGnss_InvalidateNetworkEnable; + + Accel_Init(env->accel, &env->spiPorts->accelSpi2_IO); + + env->carType = Mma_GetCarType(&env->storage.nvm->gost.VIN); + Mma_InitAudioSubsystem(env); + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация устройств завершена") +} + +void Mma_FirstStartupAudioSubsystem(tMma *env) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Тест наличия громкоговорителя отключен") + Mma_AudioTestSetMode(&env->power, 0); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск УНЧ...") + Pwm_AmpOn(&env->power); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск УНЧ выполнен") + SystemDelayMs(500); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Конфигурирование УНЧ...") + Amplifier_StartUp(&env->amplifier); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Конфигурирование УНЧ выполнено") + SystemDelayMs(500); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение УНЧ...") + Pwm_AmpOff(&env->power); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение УНЧ выполнено") + SystemDelayMs(100); + Pwm_SetMuteInCar(&env->power, false); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сигнал MUTE снят с борт. сети") + Mma_AudioTestSetMode(&env->power, 1); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Тест наличия громкоговорителя включен код 1") +} + +static void Mma_StartupDevices(tMma *env) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Включение питания антены...") + GpioPinEnable(&env->power.powerSusystem->main.inAnt); + GpioPinSet(&env->indication.uiuLed->ledsBip, true); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск акселерометра...") + Accel_StartDevice(env->accel); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск акселерометра выполнен") + AudioCodec_StartUp(&env->audioCodec); + env->adcs->boardVoltageVal.calibCoef = env->storage.nvm->device.boardCalibCoef; + Adc_BoardVoltage(&env->adcs->boardVoltageVal); +} + +void Mma_InitCrachDetectSettings(tMma *env) { + env->storage.runtime.flip.gravity = (vector3) {(float) env->storage.nvm->device.AccelCalibrationX / 1333, + (float) env->storage.nvm->device.AccelCalibrationY / 1333, + (float) env->storage.nvm->device.AccelCalibrationZ / 1333}; + + float angle = (float) (env->storage.nvm->device.RolloverAngle * 3.141592 / 180); + env->storage.runtime.flip.thresholds.angleCos = cosf(angle); + env->storage.runtime.flip.thresholds.antiFlightMs = env->storage.nvm->device.RolloverTime * 100; + env->storage.runtime.flip.enabled = env->storage.nvm->device.AccelFlipEnable; +} + +static void Mma_PreInitSubSystems(tMma *env) { + SystemSelectorInit( + &env->systemSelector, + &env->gsmWithGnss.gsmAt, + &env->slog.logger, + &env->power.powerSusystem->sim7600 + ); + + ModemDataCollectorItit( + &env->ModemDataCollector, + &env->power.powerSusystem->sim7600, + &env->slog.logger, + &env->gsmWithGnss.gsmAt, + &env->storage, + &env->systemSelector + ); + + + +// void SystemSwitcherInit( +// tSystemSwitcher *env, +// tSystemSelector *systemSelector, +// tModemDataColl *modemDataCollector, +// tLoggerInterface *logger, +// tDeviceStorage *storage, +// eUveosDoNothing *uveosDoNothingMode, +// eTelematicaIsConnect *telematicaIsConnect +// ) + + + SystemSwitcherInit( + &env->systemSwitcher, + &env->systemSelector, + &env->ModemDataCollector, + &env->slog.logger, + &env->storage, + &env->uveos.doNothing.mode, + &env->telematicaIsConnect, + &env->fl_iniSysIsDone + ); +} + +static void Mma_InitSubSystems(tMma *env) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация подсистем...") + + env->userInputSubstart = SUB_START_MODE_UNDEF; + CrashDetection_Init( + &env->crashDetect, + &env->accel->accelDataFlow, + &env->storage.nvm->gost.ASI15_TRESHOLD, + &env->storage.runtime.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_VIRT_BUTTON_ADDITIONAL, + + &env->gsmWithGnss.audioPlayerIO, + &env->rtc->rtcI0, + 0 + ); + + env->uveos.simSelecror_func = ModemDataCollector_SelectionSimChipCoolBack; + env->uveos.selecrorEnv = (void *) &env->systemSelector; + + UserInput_Init( + &env->userInput, + &env->gpios->bip.buttons, + &env->storage.nvm->gost.SOS_BUTTON_TIME, + &env->storage.nvm->gost.notGost.TEST_BUTTON_TIME + ); + + DeviceTesting_Init( + &env->testing, + + &env->userInput.watcher, + &env->gpios->powerSusystem.main.ignition, + &env->adcs->antGnss.vccIo, + &env->power.powerSusystem->SpekTestPower, + &env->gpios->bip, + &env->power.powerSusystem->battery, + env->accel, + + &env->gsmWithGnss, + &env->audioCodec, + &env->slog.logger, + + &env->gsmWithGnss.gsmAt, + &env->gsmWithGnss.audioPlayerIO, + &env->gsmWithGnss.audioRecorderIO, + + &env->userInput.buttonsInterface, + &env->indication, + &env->uveos, + &env->storage.nvm->device.useInternalAnt, + NULL, + &env->power, + &env->storage, + &env->indication.mode, + &env->amplifier, + &env->ModemDataCollector, + &env->queryUDSState, + &env->storage.nvm->device.boardCalibCoef, + &env->storage.nvm->device.telematicaIsActive, + &env->storage.runtime.telematicaServerIsActive, + ((tMmaTele *) EXT_ENV_ADR_TELE.META_EXT_ENV_TELE)->deviceTestingCodeCan + ); +/* + Cli_Init( + &env->cli, + &env->serialPorts->Debug_IO, + &env->serialPorts->Modem_snif_IO, + &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, + &env->accel.accel.xyz, + &env->crashDetect.carCrashDetection + ); +*/ + + Cli_Init( + &env->cliVrt, + &env->serialPorts->cliVirtualInIo, + NULL, + &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, + &env->accel->accel.xyz, + &env->crashDetect.carCrashDetection + ); + + InitThreadAtrStatic(&env->threadSubstartChekButton.attr, "Thread_Substart", + env->threadSubstartChekButton.controlBlock, + env->threadSubstartChekButton.stack, osPriorityNormal); + + InitThreadAtrStatic(&env->threadAccompanMode.attr, "Thread_FactoryMode", + env->threadAccompanMode.controlBlock, + env->threadAccompanMode.stack, osPriorityNormal); + + Mma_InitComInt(env, &env->storage.nvm->device.serialNumber.value, &env->storage.publicVariablesTable); + + AudioCodec_SetVolumeExternal(&env->audioCodec, &env->uveos.settings->notGost.CODEC_VOLUE_LEVEL); + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация подсистем завершена") +} + +static void Mma_RunSubThreads(tMma *env) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск субпотоков...") + + VarsTabDumpObserver_StartThread(&env->storage.dumpObserver); + +// Accel_StartThread(&env->accel); + TMR1_Accel_TmrStart(env->accel); +// Cli_StartThread(&env->cli); + + Cli_StartThread(&env->cliVrt); + UserInput_StartThread(&env->userInput); + + AccompanModeStartThread(env); + UserInputInfoSystemToUDS(env); + + + ComInt_StartThread(&env->comInt); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Субпотоки запущены") +} + +static void Mma_InitPower(tMma *env) { + Pwm_Init( + &env->power, + &env->gpios->powerSusystem, + &env->adcs->battery.vccIo, + &env->adcs->boardVoltageVal, + &env->storage.nvm->device.useMutePositive, + &env->slog, + &env->gpios->bip.buttons.emergency, + &env->gpios->bip.buttons.additional + ); + + Pwm_OnDeviceInit(&env->power); + GpioPinEnable(&env->gpios->bip.Backlight); + + PowerManagement_StartThread(&env->power); +} + +static void Mma_InitLogger(tMma *env) { + LoggerToSerialPort_Init( + &env->slog, + 3, + &env->serialPorts->cliVirtualInIo, + &env->rtc->rtcI0, + 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_UVEOS_SYSTEM_STARTUP, + &env->gpios->bip.led, + &env->gpios->onBoardLed + ); + + UserIndication_StartThread(&env->indication); +} + +void Routine_Can_UDS(void *envRoutine, + eUdsRoutineIdentifier udsRoutineIdentifier, + eUdsRoutineModes udsRoutineModes, + eUdsRoutineControlType udsRoutineControlType, + eUdsStartStopRoutineResult *udsStartStopRoutineResult, + eUdsRequestRoutineResult *udsRequestRoutineResult +) { + + tMma *env = envRoutine; + // Запросить состояние выполнения функции УВЭОС + if (udsRoutineControlType == UDS_RequestRoutineResults) { + if ( + (env->queryUDSState.state == QUERY_STOP) || + (env->queryUDSState.state == QUERY_INIT) || + (env->queryUDSState.state == QUERY_BUSY) + ) { + *udsRequestRoutineResult = UDS_RoutineStop; + } + + if (env->queryUDSState.state == QUERY_RUN) { + *udsRequestRoutineResult = UDS_RoutineRun; + } + if (env->queryUDSState.state == QUERY_ERROR) { + *udsRequestRoutineResult = UDS_RoutineFinishError; + } + if (env->queryUDSState.state == QUERY_DONE) { + *udsRequestRoutineResult = UDS_RoutineFinishSuccess; + } + + } + + // Запуск функции УВЭОС, выполнение калибровки индикации напряжения на плате + if (udsRoutineIdentifier == Clear_EEPROM) { + if (env->queryUDSState.state != QUERY_BUSY) { + env->state.GsmRegistartionStateMem = 0; + env->queryUDSState.state = QUERY_RUN; + env->queryUDSState.commands = COM_RUN; + *udsRequestRoutineResult = UDS_RoutineRun; + + if (udsRoutineControlType == UDS_StartRoutine) { + env->eolAcsess = true; + *udsStartStopRoutineResult = RoutineStartStopSuccess; + } + if (env->eolAcsess == false) { + *udsRequestRoutineResult = UDS_RoutineFinishSuccess; + } + + } + } + + if (udsRoutineIdentifier == UDS_ModuleRegistration) { + if (udsRoutineControlType == UDS_StartRoutine) { + if (env->queryUDSState.state != QUERY_BUSY) { + *udsRequestRoutineResult = UDS_RoutineRun; + env->queryUDSState.source = REG_TO_NETWORK; + env->queryUDSState.state = QUERY_RUN; + env->queryUDSState.commands = COM_RUN; + *udsStartStopRoutineResult = RoutineStartStopSuccess; + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск запрашиваемого теста НЕ возможен") + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка получения регистрации") + *udsStartStopRoutineResult = RoutineStartStopFailure; + } + } + } + + if (udsRoutineIdentifier == UDS_BoardVoltageCalibration) { + if (udsRoutineControlType == UDS_StartRoutine) { + if (env->queryUDSState.state != QUERY_BUSY) { + *udsRequestRoutineResult = UDS_RoutineRun; + env->queryUDSState.source = REG_BOARD_VOLTAGE_CALIBRATION; + env->queryUDSState.state = QUERY_RUN; + env->queryUDSState.commands = COM_RUN; + *udsStartStopRoutineResult = RoutineStartStopSuccess; + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Запуск процедуры калибровки чтения напряжения бортовой сети не возможен") + *udsStartStopRoutineResult = RoutineStartStopFailure; + } + } + } + + // Запуск функции УВЭОС, выполнение тестов + if (udsRoutineIdentifier == UDS_Self_Test) { + + if (udsRoutineControlType == UDS_StartRoutine) { + if (env->queryUDSState.state != QUERY_BUSY) { + + if (udsRoutineModes == UDS_SosTestCallNoMTS) { + if (env->ModemDataCollector.modemVersionRevision.valid_CCID == MOD_READY) { + env->queryUDSState.source = ECALL_NOT_REG_TEST; + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск запрашиваемого теста НЕ возможен") + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка оборудования") + *udsStartStopRoutineResult = RoutineStartStopFailure; + env->queryUDSState.state = QUERY_ERROR; + return; + } + } + + if (udsRoutineModes == UDS_MicrophoneDynamic) { + env->queryUDSState.source = SPEAK_MICR_TEST; + } + + if (udsRoutineModes == UDS_SosTestCall) { + if (env->ModemDataCollector.modemVersionRevision.valid_CCID == MOD_READY) { + env->queryUDSState.source = ECALL_TEST; + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск запрашиваемого теста НЕ возможен") + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка оборудования") + *udsStartStopRoutineResult = RoutineStartStopFailure; + env->queryUDSState.state = QUERY_ERROR; + return; + } + } + + if (udsRoutineModes == UDS_LEDs) { + env->queryUDSState.source = LEDS_TEST; + } + + env->queryUDSState.state = QUERY_RUN; + env->queryUDSState.commands = COM_RUN; + *udsStartStopRoutineResult = RoutineStartStopSuccess; + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск запрашиваемого теста НЕ возможен") + LoggerInfoStatic(LOGGER, LOG_SIGN, + "Запрашиваемый тест может быть запущен только из режимов ЭРА или ПОИСК GNSS или ОШИБКА") + *udsStartStopRoutineResult = RoutineStartStopFailure; + } + } + + } + + // Останов функции УВЭОС + if (udsRoutineControlType == UDS_StopRoutine) { + if (env->queryUDSState.state == QUERY_RUN) { + env->queryUDSState.commands = COM_STOP; + *udsStartStopRoutineResult = RoutineStartStopSuccess; + } else { + *udsStartStopRoutineResult = RoutineStartStopFailure; + } + } + +} + +void Function_Can_UDS(void *envFunction, + eTypeFunctionCanUds typeFunctionCanUds, + void *dataFunctionCanUdsEnv +) { + tMma *env = envFunction; + + if (typeFunctionCanUds == AUDIO_TEST_PLAY_CAN_UDS) { + Mma_AudioSubSystemRequire(env); + if (osMutexAcquire(env->gsmWithGnss.gsmAt.access, 5000) == osOK) { + AtGsmSimComSim7600E_RecorderAudioFileStart(&env->gsmWithGnss.gsmAt, "uds.wav", + sizeof("uds.wav") - 1); + SystemDelayMs(200); + AtGsmSimComSim7600E_PlayToneUds(&env->gsmWithGnss.gsmAt); + SystemDelayMs(200); + AtGsmSimComSim7600E_RecorderAudioFileStopNotSubmit(&env->gsmWithGnss.gsmAt); + osMutexRelease(env->gsmWithGnss.gsmAt.access); + } + Mma_AudioSubSystemRelease(env); + } + + if (typeFunctionCanUds == TASK_INDICATION_STOP_START_CAN_UDS) { + eTypeFunctionCanUdsTaskIndicationStartStop functionCanUdsTaskIndicationStartStop = *(eTypeFunctionCanUdsTaskIndicationStartStop *) dataFunctionCanUdsEnv; + + switch (functionCanUdsTaskIndicationStartStop) { + + case TASK_INDICATION_STOP_CAN_UDS: + UserIndication_StopThread(&env->indication); + break; + case TASK_INDICATION_START_CAN_UDS: + UserIndication_StartThread(&env->indication); + break; + default: + break; + } + } + + if (typeFunctionCanUds == GPIO_WRITE_CAN_UDS) { + eTypeFunctionCanUdsWrite functionCanUdsWrite = *(eTypeFunctionCanUdsWrite *) dataFunctionCanUdsEnv; + + switch (functionCanUdsWrite) { + + case GPIO_FALSE_ECALL_OUT_CAN_UDS: + GpioPinDisable(&env->power.powerSusystem->main.ecallOut); + break; + + + case GPIO_TRUE_ECALL_OUT_CAN_UDS: + GpioPinEnable(&env->power.powerSusystem->main.ecallOut); + break; + + + case GPIO_FALSE_GARAGE_CAN_UDS: + GpioPinDisable(&env->power.powerSusystem->main.garage); + break; + + + case GPIO_TRUE_GARAGE_CAN_UDS: + GpioPinEnable(&env->power.powerSusystem->main.garage); + break; + + + case GPIO_FALSE_MUTE_P_CAN_UDS: + GpioPinDisable(&env->power.powerSusystem->main.muteP); + break; + + + case GPIO_TRUE_MUTE_P_CAN_UDS: + GpioPinEnable(&env->power.powerSusystem->main.muteP); + break; + + + case GPIO_FALSE_MUTE_N_CAN_UDS: + GpioPinDisable(&env->power.powerSusystem->main.muteN); + break; + + + case GPIO_TRUE_MUTE_N_CAN_UDS: + GpioPinEnable(&env->power.powerSusystem->main.muteN); + break; + + + case GPIO_FALSE_LED_RED_CAN_UDS: + GpioPinDisable(&env->indication.uiuLed->red); + break; + + + case GPIO_TRUE_LED_RED_CAN_UDS: + GpioPinEnable(&env->indication.uiuLed->red); + break; + + + case GPIO_FALSE_LED_GREEN_CAN_UDS: + GpioPinDisable(&env->indication.uiuLed->green); + break; + + + case GPIO_TRUE_LED_GREEN_CAN_UDS: + GpioPinEnable(&env->indication.uiuLed->green); + break; + + default: + break; + + } + } + +} + +void Mma_TelematicaAdressForeardind(tMma *env) { + tMmaTele *MAIN_ENV_TELE_P; + + MAIN_ENV_TELE_P = (tMmaTele *) EXT_ENV_ADR_TELE.META_EXT_ENV_TELE; + EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_PRE_INIT); + + MAIN_ENV_TELE_P->osFreeRTOS.osMessageQueueNew = osMessageQueueNew; + MAIN_ENV_TELE_P->osFreeRTOS.osMessageQueuePut = osMessageQueuePut; + MAIN_ENV_TELE_P->osFreeRTOS.osMessageQueueGet = osMessageQueueGet; + MAIN_ENV_TELE_P->osFreeRTOS.osMessageQueueReset = osMessageQueueReset; + MAIN_ENV_TELE_P->osFreeRTOS.osMessageQueueGetSpace = osMessageQueueGetSpace; + MAIN_ENV_TELE_P->osFreeRTOS.osMessageQueueGetCount = osMessageQueueGetCount; + MAIN_ENV_TELE_P->osFreeRTOS.osThreadTerminate = osThreadTerminate; + MAIN_ENV_TELE_P->osFreeRTOS.osThreadSuspend = osThreadSuspend; + MAIN_ENV_TELE_P->osFreeRTOS.osThreadResume = osThreadResume; + MAIN_ENV_TELE_P->osFreeRTOS.osThreadNew = osThreadNew; + MAIN_ENV_TELE_P->osFreeRTOS.osMutexNew = osMutexNew; + MAIN_ENV_TELE_P->osFreeRTOS.osMutexAcquire = osMutexAcquire; + MAIN_ENV_TELE_P->osFreeRTOS.osMutexRelease = osMutexRelease; + MAIN_ENV_TELE_P->osFreeRTOS.malloc = malloc; + MAIN_ENV_TELE_P->osFreeRTOS.free = free; + MAIN_ENV_TELE_P->osFreeRTOS.SystemDelayMs = SystemDelayMs; + MAIN_ENV_TELE_P->osFreeRTOS.SystemGetMs = SystemGetMs; + MAIN_ENV_TELE_P->osFreeRTOS.nvic_system_reset = nvic_system_reset; + + MAIN_ENV_TELE_P->CanPort_SetSpeed = CanPort_SetSpeed; + + MAIN_ENV_TELE_P->Routine_Can_UDS_env = env; + MAIN_ENV_TELE_P->Routine_Can_UDS = Routine_Can_UDS; + + MAIN_ENV_TELE_P->ignition = &env->gpios->powerSusystem.main.ignition; + MAIN_ENV_TELE_P->rtcIO = &env->rtc->rtcI0; + MAIN_ENV_TELE_P->loggerToSerialPort = &env->slog; + + + MAIN_ENV_TELE_P->store.AdditionalSettings = &env->storage.nvm->AdditionalSettings; + MAIN_ENV_TELE_P->store.device = &env->storage.nvm->device; + MAIN_ENV_TELE_P->store.gost = &env->storage.nvm->gost; + MAIN_ENV_TELE_P->store.dataTeledata = env->storage.nvm->dataTeledata; + MAIN_ENV_TELE_P->store.publicVariablesTable = &env->storage.publicVariablesTable; + MAIN_ENV_TELE_P->store.runtime = &env->storage.runtime; + + MAIN_ENV_TELE_P->DataToCan = &env->storage.nvm->DataToCan; + + + MAIN_ENV_TELE_P->store.accessDumper = env->storage.dumpObserver.accessDumper; + MAIN_ENV_TELE_P->store.uveosDumper = &env->storage.uveosDumper; + + MAIN_ENV_TELE_P->gnss.currentRmc = &env->gsmWithGnss.gnss.currentRmc; + MAIN_ENV_TELE_P->gsmAt = &env->gsmWithGnss.gsmAt; + MAIN_ENV_TELE_P->testsTable = &env->testing.testsTable; + MAIN_ENV_TELE_P->vccIo = &env->adcs->battery.vccIo; + + MAIN_ENV_TELE_P->gnss.rmcAccess = env->gsmWithGnss.gnss.rmcAccess; + + MAIN_ENV_TELE_P->Can1_IO = &env->canPorts->Can1_IO; + MAIN_ENV_TELE_P->Can2_IO = &env->canPorts->Can2_IO; + + MAIN_ENV_TELE_P->SystemStateID_0006 = &env->SystemStateID_0006; + MAIN_ENV_TELE_P->InputStatesRecord_0001 = &env->InputStatesRecord_0001; + MAIN_ENV_TELE_P->OutputStatesRecord_0002 = &env->OutputStatesRecord_0002; + + MAIN_ENV_TELE_P->BoardVoltage = &env->state.BoardVoltage; + MAIN_ENV_TELE_P->ReserveBatteryCharge = &env->state.ReserveBatteryCharge; + MAIN_ENV_TELE_P->ReserveBatteryTemperature = &env->state.ReserveBatteryTemperature; + MAIN_ENV_TELE_P->VehicleCoordinates = &env->state.VehicleCoordinates; + MAIN_ENV_TELE_P->VehicleCoordinatesReliability = &env->state.VehicleCoordinatesReliability; + MAIN_ENV_TELE_P->MDS_FormatVersion = &env->state.MDS_FormatVersion; + MAIN_ENV_TELE_P->TCM_working_mode = &env->state.TCM_working_mode; + MAIN_ENV_TELE_P->TCM_activation_source = &env->state.TCM_activation_source; + MAIN_ENV_TELE_P->TCM_time_calculation = &env->state.TCM_time_calculation; + MAIN_ENV_TELE_P->GLONASS_and_GLONASS_GPS_groups = &env->state.GLONASS_and_GLONASS_GPS_groups; + MAIN_ENV_TELE_P->GsmRegistrationState = &env->state.GsmRegistrationState; + MAIN_ENV_TELE_P->TimeStamp = &env->state.TimeStamp; + MAIN_ENV_TELE_P->GsmInnerError = &env->state.GsmInnerError; + MAIN_ENV_TELE_P->VehicleCoordinatesReliabilityMem = &env->state.VehicleCoordinatesReliabilityMem; + MAIN_ENV_TELE_P->GsmRegistartionStateMem = &env->state.GsmRegistartionStateMem; + MAIN_ENV_TELE_P->GsmRegistrationError = &env->state.GsmRegistrationError; + MAIN_ENV_TELE_P->EcallOn = &env->state.EcallOn; + MAIN_ENV_TELE_P->CrashSignalExternal = &env->state.CrashSignalExternal; + MAIN_ENV_TELE_P->GnssPowerOffTime = &env->state.GnssPowerOffTime; + MAIN_ENV_TELE_P->AutomaticActivationProhibition = &env->state.AutomaticActivationProhibition; + MAIN_ENV_TELE_P->ECALLToTest = &env->state.ECALLToTest; + MAIN_ENV_TELE_P->NadRegistrationAtStartup = &env->state.NadRegistrationAtStartup; + MAIN_ENV_TELE_P->GSMSoftwareVersionNumber = env->state.GSMSoftwareVersionNumber; // 20 + MAIN_ENV_TELE_P->SmsFallbackTestNumber = env->state.SmsFallbackTestNumber; // 20 + MAIN_ENV_TELE_P->SimProfileAmount = &env->state.SimProfileAmount; + MAIN_ENV_TELE_P->SimProfile = &env->state.SimProfile; + MAIN_ENV_TELE_P->AudioProfile = &env->state.AudioProfile; + MAIN_ENV_TELE_P->EcallNoAutomaticTriggering = &env->state.EcallNoAutomaticTriggering; + MAIN_ENV_TELE_P->MiddletState = &env->state.MiddletState; + MAIN_ENV_TELE_P->Vehicle_SW_Version = env->state.Vehicle_SW_Version; // 3 + MAIN_ENV_TELE_P->Midlet_SW_Version = env->state.Midlet_SW_Version; // 3 + MAIN_ENV_TELE_P->Boot_SW_Version = env->state.Boot_SW_Version; // 27 + MAIN_ENV_TELE_P->SertState = &env->state.SertState; + MAIN_ENV_TELE_P->ApplicationCheckSum = &env->state.ApplicationCheckSum; + MAIN_ENV_TELE_P->Audio_HW_Settings = &env->state.Audio_HW_Settings; + MAIN_ENV_TELE_P->ECALL_EmergencyCallCounter = &env->state.ECALL_EmergencyCallCounter; + MAIN_ENV_TELE_P->Avaialble_Networks_List = env->state.Avaialble_Networks_List; //128 + MAIN_ENV_TELE_P->SavedMSDAmount = &env->state.SavedMSDAmount; + MAIN_ENV_TELE_P->SentMSDAmount = &env->state.SentMSDAmount; + MAIN_ENV_TELE_P->VehicleManufacturerSparePartNumber = env->state.VehicleManufacturerSparePartNumber; //10 + MAIN_ENV_TELE_P->ConfigurationFileReferenceLink = env->state.ConfigurationFileReferenceLink; //10 + MAIN_ENV_TELE_P->SystemSupplierIdentifier = env->state.SystemSupplierIdentifier; //3 + MAIN_ENV_TELE_P->ECUSerialNumber = env->state.ECUSerialNumber; //20 + MAIN_ENV_TELE_P->VehicleManufacturerECUHardwareNumber = env->state.VehicleManufacturerECUHardwareNumber; //10 + MAIN_ENV_TELE_P->SystemSupplierECUSoftwareNumber = env->state.SystemSupplierECUSoftwareNumber; //2 + MAIN_ENV_TELE_P->SystemSupplierECUSoftwareVersionNumber = env->state.SystemSupplierECUSoftwareVersionNumber; //2 + MAIN_ENV_TELE_P->VDIAG = &env->state.VDIAG; + MAIN_ENV_TELE_P->vBatVoltage = &env->power.powerSusystem->battery.currentBatVoltage; + MAIN_ENV_TELE_P->vBoardVoltage = &env->power.powerSusystem->boardPower.currentBoardVoltage; + MAIN_ENV_TELE_P->CanPort_GetSpeed = CanPort_GetSpeed; + MAIN_ENV_TELE_P->GNSS_General = &env->GNSS_General; + MAIN_ENV_TELE_P->LastEventDevice = &env->lastEventDevice; + + MAIN_ENV_TELE_P->SetDeviceFactoryMode = (void *) ModemDataCollector_ModemFlashing; + MAIN_ENV_TELE_P->SetDeviceFactoryMode_env = &env->ModemDataCollector; + + MAIN_ENV_TELE_P->SrandStdLib = srand; + MAIN_ENV_TELE_P->RandStdLib = rand; + MAIN_ENV_TELE_P->CanPort_SetFilter = CanPort_SetFilter; + + MAIN_ENV_TELE_P->Function_Can_UDS_env = env; + MAIN_ENV_TELE_P->Function_Can_UDS = Function_Can_UDS; + + EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_INIT); + +} + +void Mma_InitGSM_AudioProfile(tMma *env) { + tString32 audioProfileName = {0}; + + switch (env->carType) { + case UNDEFINDET_CAR: + LoggerInfoStatic(LOGGER, LOG_SIGN, "Установка аудио профиля в модуле GSM по умолчанию ") + memcpy(audioProfileName.data, "Handset_cal.acdb", sizeof("Handset_cal.acdb")); + audioProfileName.length = sizeof("Handset_cal.acdb"); + break; + + case SGR_MICRO_BUSS_M2G_CAR: + LoggerInfoStatic(LOGGER, LOG_SIGN, "Установка аудио профиля в модуле GSM для микроавтобуса УАЗ M2G") + memcpy(audioProfileName.data, "Handset_cal_mcrBuss_m2g.acdb", sizeof("Handset_cal_mcrBuss_m2g.acdb")); + audioProfileName.length = sizeof("Handset_cal_mcrBuss_m2g.acdb"); + break; + + case PATRIOT_M1G_CAR: + LoggerInfoStatic(LOGGER, LOG_SIGN, "Установка аудио профиля в модуле GSM для Patriot УАЗ M1G") + memcpy(audioProfileName.data, "Handset_cal_patriot_m1g.acdb", sizeof("Handset_cal_patriot_m1g.acdb")); + audioProfileName.length = sizeof("Handset_cal_patriot_m1g.acdb"); + break; + + case PROFI_N1_CAR : + LoggerInfoStatic(LOGGER, LOG_SIGN, "Установка аудио профиля в модуле GSM для УАЗ Profi") + memcpy(audioProfileName.data, "Handset_cal_prof_n1.acdb", sizeof("Handset_cal_prof_n1.acdb")); + audioProfileName.length = sizeof("Handset_cal_prof_n1.acdb"); + break; + + case KIND_M2G_BUSS : + LoggerInfoStatic(LOGGER, LOG_SIGN, "Установка аудио профиля в модуле GSM для УАЗ Школьный автобус") + memcpy(audioProfileName.data, "Handset_cal_kindBus_m2g.acdb", sizeof("Handset_cal_kindBus_m2g.acdb")); + audioProfileName.length = sizeof("Handset_cal_kindBus_m2g.acdb"); + break; + + case HUNTER_N1G : + LoggerInfoStatic(LOGGER, LOG_SIGN, "Установка аудио профиля в модуле GSM для УАЗ Patriot Хантер") + memcpy(audioProfileName.data, "Handset_cal_hunter_n1g.acdb", sizeof("Handset_cal_hunter_n1g.acdb")); + audioProfileName.length = sizeof("Handset_cal_hunter_n1g.acdb"); + break; + + case SGR_DUMP_TRUCK_N1G : + LoggerInfoStatic(LOGGER, LOG_SIGN, "Установка аудио профиля в модуле GSM для УАЗ самосвал") + memcpy(audioProfileName.data, "Handset_cal_truck_n1g.acdb", sizeof("Handset_cal_truck_n1g.acdb")); + audioProfileName.length = sizeof("Handset_cal_truck_n1g.acdb"); + break; + + default: + break; + } + + if (GsmWithGnssConfigureAudioProfile(&env->gsmWithGnss, &audioProfileName) == AT_ERROR) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка установки аудио профиля") + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Аудио профиль установлен") + } +} + +eCarType Mma_GetCarType(tString32 *env) { + char buf[6] = {0}; + memset(buf, 0, 6); + + uint8_t j = 3; + for (uint8_t i = 0; i < sizeof(buf); i++) { + buf[i] = env->data[j]; + j++; + } + if (memcmp(buf, "330365", sizeof(buf)) == 0) { + return SGR_DUMP_TRUCK_N1G; + } + if (memcmp(buf, "220695", sizeof(buf)) == 0) { + return SGR_MICRO_BUSS_M2G_CAR; + } + if (memcmp(buf, "316300", sizeof(buf)) == 0) { + return PATRIOT_M1G_CAR; + } + if (memcmp(buf, "236031", sizeof(buf)) == 0) { + return PROFI_N1_CAR; + } + if (memcmp(buf, "128801", sizeof(buf)) == 0) { + return KIND_M2G_BUSS; + } + if (memcmp(buf, "292400", sizeof(buf)) == 0) { + return HUNTER_N1G; + } + return UNDEFINDET_CAR; +} + +bool Mma_StartCrachDetectSubsystem(tMma *env) { + if ( + (DeviceTestsTable_MakeTest(env->testing.namedTests.accel) == DEVICE_TESTING_CODE_PASSED) && + (DeviceTestsTable_MakeTest(env->testing.namedTests.accel_calib) == DEVICE_TESTING_CODE_PASSED) && + (DeviceTestsTable_MakeTest(env->testing.namedTests.vin) == DEVICE_TESTING_CODE_PASSED) + ) { + + Mma_InitCrachDetectSettings(env); + SystemDelayMs(500); + Accel_Clear(env->accel); + CrashDetection_StartThread(&env->crashDetect); + SystemDelayMs(500); + return true; + } else { + return false; + } +} + +void Mma_InitStage(tMma *env) { + + ///* Перенос инициализации Логгера и стореджа в начало, перед Mma_InitPower + + Mma_InitLogger(env); + + bool b = DeviceStorage_Init(&env->storage, &env->flash->interface); + if (!b) { + Mma_FatalErrorOnInit(env, true, DEVICE_MODE_ERROR_FLASH); + } + Mma_InitPower(env); + + env->gsmWithGnss.gsmState = GSM_INITIALIZING; + env->queryUDSState.commands = COM_INIT; + env->queryUDSState.state = QUERY_INIT; + env->state.GsmRegistartionStateMem = 2; + env->storage.runtime.telematicaWaitConnect = false; + + ModemDataCollector_SetThisSubSystem(&env->systemSelector, UNDEFANDET); + env->storage.runtime.EGTS_FLEET_ON = false; + InfoToUDS_InitSetDefault(env); + + bool isTelematica = loadMetaTelematica(); + if (isTelematica) { + setGeneralGNSS(env, + CAN_GNSS_NO_CALL, + CAN_GNSS_SYSTEM_INITIALISATION, + CAN_GNSS_NO_ROLLOVER_DETECT, + CAN_GNSS_CALL_TEST_NOT_ACTIVE + ); + CanPorts_Init(); + Mma_TelematicaAdressForeardind(env); + + env->ModemDataCollector.modemVersionRevision.softValue.length = env->storage.nvm->modemSaveDeviceSoftVers.length; + memcpy(env->ModemDataCollector.modemVersionRevision.softValue.data, env->storage.nvm->modemSaveDeviceSoftVers.data, + env->storage.nvm->modemSaveDeviceSoftVers.length); + + memset(env->state.GSMSoftwareVersionNumber, 0, sizeof(env->state.GSMSoftwareVersionNumber)); + memcpy(env->state.GSMSoftwareVersionNumber, env->storage.nvm->modemSaveDeviceSoftVers.data, + env->storage.nvm->modemSaveDeviceSoftVers.length); + + EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_CAN_UDS_START); + } + + // Антидребезг линии зажигания + for (uint8_t i = 0; i < 50; ++i) { + bool ignition = GpioPinGet(&env->gpios->powerSusystem.main.ignition); + if (ignition == false) { + nvic_system_reset(); + } + SystemDelayMs(10); + } + + Pwm_GsmAndGnssStartup(&env->power); + + Mma_InitAndRunIndication(env); + Mma_SetMode(env, DEVICE_MODE_UVEOS_SYSTEM_STARTUP); + Mma_InitPeripheralDevices(env); + Mma_StartupDevices(env); + Mma_PreInitSubSystems(env); + Mma_InitSubSystems(env); + + env->indication.bipPowerMode = env->uveos.settings->notGost.BIP_POWER_MODE; + + Mma_RunSubThreads(env); + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализируем звуковую подсистему(кодек,усилитель)") + Mma_FirstStartupAudioSubsystem(env); + SystemDelayMs(500); + Mma_AudioSubSystemRelease(env); + + LoggerCnInfoStatic(LOGGER, LOG_SIGN, "Ожидание первых данные от акселерометра...") + if (Accel_WaitReady(env->accel, 2000)) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "получены") + } else { + LoggerInfoStatic(LOGGER, LOG_SIGN, "данные от акселерометра ОТСУТСТВУЮТ!") + } + + if (DeviceTestsTable_MakeTest(env->testing.namedTests.accel) != DEVICE_TESTING_CODE_PASSED) { + if (env->storage.nvm->device.factoryMode == false) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка начального тестирования, ошибка акселерометра!!!") + env->GNSS_General.GNSS_Status = CAN_GNSS_FAILURE; + Mma_FatalErrorOnInit(env, false, DEVICE_MODE_ERROR_ON_INIT_TEST1); + } + } + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Начальное тестирование ч.1 пройдено") + Mma_GetHardVers(env); + Mma_GetSoftVers(env); + + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ожидание загрузки GSM...") + uint32_t tm = SystemGetMs() + 10000; + bool statModem = false; + while (tm > SystemGetMs()) { + if (GpioPinGet(&env->power.powerSusystem->sim7600.powerStatus) == true) { + statModem = true; + break; + } + SystemDelayMs(10); + } + + Pwm_LNA_setMode(&env->power, env->storage.nvm->device.useInternalAnt); + + if (statModem == true) { + while (!GsmWaitFirstStartup(&env->gsmWithGnss)) { + Mma_SetMode(env, DEVICE_MODE_ERROR_GSM); + env->gsmWithGnss.gsmState = GSM_ERROR; + } + + ModemDataCollector_GetCCIDS(&env->ModemDataCollector); + LoggerInfoStatic(LOGGER, LOG_SIGN, "CCID считаны") + ModemDataCollector_GetCGSN(&env->ModemDataCollector); + LoggerInfoStatic(LOGGER, LOG_SIGN, "CGSN считан") + ModemDataCollector_GetSoftRev(&env->ModemDataCollector); + LoggerInfoStatic(LOGGER, LOG_SIGN, "SoftRev считан") + ModemDataCollector_GetSertRev(&env->ModemDataCollector); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Сертификаты проверены") + ModemDataCollector_GetAudioRev(&env->ModemDataCollector); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Аудио файлы проверены") + LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализирована загрузка аудио профилей в GSM") + Mma_InitGSM_AudioProfile(env); + LoggerInfoStatic(LOGGER, LOG_SIGN, "Загрузка аудио профилей в GSM завершена") + + Gsm_SetManualModemPower( + &env->gsmWithGnss, + &env->uveos.settings->notGost.MANUAL_SET_MODEM_POWER, + &env->uveos.settings->notGost.MODEM_POWER_FOR_LTE_MODE, + &env->uveos.settings->notGost.MODEM_POWER_FOR_WCDMA_MODE, + &env->uveos.settings->notGost.MODEM_POWER_FOR_GSM_MODE + ); + + GsmWithGnss_startUrcThread(&env->gsmWithGnss); + Gsm_WaitGsmBoot(&env->gsmWithGnss); + tStringLink profileExt; + + profileExt.data = env->storage.nvm->device.simProfile.data; + profileExt.length = &env->storage.nvm->device.simProfile.length; + if (GsmWithGnssSimProfileSelect(&env->gsmWithGnss.gsmAt, profileExt) == AT_ERROR) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка установки сим профиля") + } + env->ModemDataCollector.fl_IsLoad = true; + env->gsmWithGnss.gsmState = GSM_IDLE; + } + + uint16_t *modemVersionRevisionTest; + modemVersionRevisionTest = getResultFix(&env->testing.testsTable, "GSM", sizeof("GSM") - 1); + if (*modemVersionRevisionTest == DEVICE_TESTING_CODE_ERROR) { + Mma_SetMode(env, DEVICE_MODE_ERROR_GSM); + } + + if (DeviceTestsTable_MakeTest(env->testing.namedTests.bipConnect) != DEVICE_TESTING_CODE_CONNECTED) { + if (env->storage.nvm->device.factoryMode == false) { + LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка начального тестирования, ошибка подключения БИП-а!!!") + env->GNSS_General.GNSS_Status = CAN_GNSS_FAILURE; + Mma_FatalErrorOnInit(env, false, DEVICE_MODE_ERROR_ON_INIT_TEST2); + } + } + LoggerInfoStatic(LOGGER, LOG_SIGN, "Начальное тестирование ч.2 пройдено") + + if (env->storage.nvm->gost.notGost.ECALL_DEBUG_MODE) { + if (env->power.powerSusystem->SpekTestPower.speakTestAcsess == true) { + env->power.powerSusystem->SpekTestPower.speakTestAcsess = false; + Mma_AudioSubSystemRequire(env); + } + LoggerInfoStatic(LOGGER, LOG_SIGN, "СИСТЕМА В РЕЖИМЕ ОТЛАДКИ"); + } + + env->lastEventDevice = LAST_EVENT_NONE; + env->SystemStateID_0006.TCM_State = 0; + env->fl_iniSysIsDone = true; + if (EXT_ENV_ADR_TELE.META_EXT_ENV_TELE) { + EXT_ENV_ADR_TELE.tele_func(env, TELE_MODULE_START); + } + + env->GNSS_General.GNSS_Status = CAN_GNSS_NO_MALFUNCTIONS; +} + + diff --git a/MainModesArbiter_Private.h b/MainModesArbiter_Private.h new file mode 100644 index 0000000..131c711 --- /dev/null +++ b/MainModesArbiter_Private.h @@ -0,0 +1,122 @@ +// +// 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)) + +typedef enum { + SUB_START_MODE_UNDEF = 0, + SUB_START_MODE_EMER = 1, + SUB_START_MODE_TESTING = 2, + SUB_START_MODE_NOT_SEND_MSD = 3, +} tSubStartMode; + +eCarType Mma_GetCarType(tString32 *env); + +void Mma_RunShortTest(tMma *env, bool blocEcall); + +void Mma_InitGSM_AudioProfile(tMma *env); + +tDeviceModes *UserIndication_GetMode(tMma *env); + +void Mma_ReleaseEcallSubSystems(tMma *env); + +void Mma_ProcessCallAnswer(tMma *env); + +void Mma_InitCrachDetectSettings(tMma *env); + +void Mma_SubstartTelematica(tMma *env); + +void Mma_AccompanMode(tMma *env); + +void Mma_ClearParams(tMma *env); + +void Mma_PassedMode(tMma *env); + +static _Noreturn void Mma_UserInputSubstartButtonThread(tMma *env); + +void InfoToUDS_InitSetDefault(tMma *env); + +void Mma_SystemSelector(tMma *env, eSubSystems subSystems); + +void Mma_SelectorOneSystem(tMma *env, eSubSystems subSystems); + +void Mma_RunTests(tMma *env); + +void Mma_gnssUpdateIndication(tMma *env); + +void Mma_RunUserTests(tMma *env, bool releaseAudioSubSystem); + +//void Mma_ControlCapture(tMma *env, eControlCapture Capture); + +void Mma_AudioSubSystemStart(tPowerManagement *power, tAmplifier *amplifier); + +void UserInputInfoSystemToUDS(tMma *env); + +void Mma_FirstStartupAudioSubsystem(tMma *env); + +void Mma_DeletSms(tMma *env); + +void Mma_AudioTestSetMode(tPowerManagement *env, bool fl); + +void Mma_FatalErrorOnInit(tMma *env, bool noinit, tDeviceModes errState); + +void Mma_delayNotBloc(uint32_t tim); + +void Mma_UserInputSubstartButtonThreadStart(tMma *env); + +void Mma_UserInputSubstartButtonThreadStop(tMma *env); + +void AccompanModeStartThread(tMma *env); + +void UserInputChekButton(tMma *env); + +void Mma_InitStage(tMma *env); + +void Mma_CheckShutdown(tMma *env) ; + +AtCommandResult Mma_CheckIncomingSms(tMma *env); + +void Mma_NetworkRequire(tMma *env); + +void TMR2_CanMute_Start(tMma *env); + +void Mma_EcallManual(tMma *env); + +bool Mma_StartCrachDetectSubsystem(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_AudioSubSystemRelease(tMma *env); + +void Mma_AudioSubSystemRequire(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); + +void setGeneralGNSS(tMma *env, + eCanGnssCallByButton GNSS_Call_By_button, + eCanGnssStatus GNSS_Status, + eCanGnssCallAuto GNSS_Call_Auto, + eCanGnssCallTest GNSS_Call_Test +); + + +//void Mma_SetAccessProtection(); + +#endif //UVEOS_ON_NATION_MAINMODESARBITER_PRIVATE_H diff --git a/PeripheralInterfaces.c b/PeripheralInterfaces.c new file mode 100644 index 0000000..e147fdb --- /dev/null +++ b/PeripheralInterfaces.c @@ -0,0 +1,16 @@ +// +// Created by xemon on 11.12.22. +// +#include "PeripheralInterfaces.h" +#include "Rtcs.h" + +void InitPeripheralInterfaces() { + Gpios_Init(); + Adcs_Init(); + SerialPorts_Init(&GPIOS.comIntDir); + I2cPorts_Init(); + SpiPorts_Init(&GPIOS.accel); + CanPorts_Init(); + StorageOnFlash_Init(); + Rtcs_Init(); +} \ No newline at end of file diff --git a/PeripheralInterfaces.h b/PeripheralInterfaces.h new file mode 100644 index 0000000..d480ff9 --- /dev/null +++ b/PeripheralInterfaces.h @@ -0,0 +1,18 @@ +// +// Created by xemon on 11.12.22. +// + +#ifndef UVEOS_ON_NATION_DEVICE_PERIPHERALINTERFACES_H +#define UVEOS_ON_NATION_DEVICE_PERIPHERALINTERFACES_H + +#include +#include +#include +#include +#include +#include +#include "CanPorts.h" + +void InitPeripheralInterfaces(); + +#endif //UVEOS_ON_NATION_DEVICE_PERIPHERALINTERFACES_H diff --git a/TelematicaConnectStatus.h b/TelematicaConnectStatus.h new file mode 100644 index 0000000..21a8da2 --- /dev/null +++ b/TelematicaConnectStatus.h @@ -0,0 +1,15 @@ +// +// Created by zemon on 09.10.24. +// + +#ifndef SMART_COMPONENTS_V2_TELEMATICACONNECTSTATUS_H +#define SMART_COMPONENTS_V2_TELEMATICACONNECTSTATUS_H + +typedef enum { + TELE_ACSESS_DENATED = 0, + TELE_ACSESS_SERVER = 1, + TELE_ACSESS_LOCAL = 2, + TELE_ACSESS_TEMPORARY = 3, +}eTelematicaIsConnect; + +#endif //SMART_COMPONENTS_V2_TELEMATICACONNECTSTATUS_H diff --git a/modular.json b/modular.json new file mode 100644 index 0000000..0dd1901 --- /dev/null +++ b/modular.json @@ -0,0 +1,10 @@ +{ + "cmake": { + "inc_dirs": [ + "./" + ], + "srcs": [ + "./**.c" + ] + } +} \ No newline at end of file