796 lines
30 KiB
C
796 lines
30 KiB
C
//
|
||
// Created by xemon on 30.10.22.
|
||
//
|
||
|
||
|
||
#include <AudioPlayerInterface.h>
|
||
#include <SystemDelayInterface.h>
|
||
#include "DeviceTesting.h"
|
||
#include "UserInput.h"
|
||
#include "DeviceTesting_TestsWithUser.h"
|
||
#include "Adc.h"
|
||
#include "EraGlonassMsd.h"
|
||
#include "EraGlonassUveos.h"
|
||
#include "Accel.h"
|
||
#include "GsmWithGnss.h"
|
||
#include "AsciiStringAssmeblingUtils.h"
|
||
#include "semphr.h"
|
||
#include "MainModesArbiter_Private.h"
|
||
|
||
#define LOGGER env->logger
|
||
#define LOG_SIGN "Тест."
|
||
|
||
bool DeviceTesting_Init(
|
||
tDeviceTesting *env,
|
||
|
||
tUserInputButtonWatcher *UserInputButtonWatcher,
|
||
tGpioPin *ignPin,
|
||
tAdcIO *gnssAntAdc,
|
||
tSpekTestPower *spekTestPower,
|
||
tBipPins *bipDiagnost,
|
||
tBatteryPower *batteryPower,
|
||
tAccel *accel,
|
||
|
||
tGsmWithGnss *gsmWithGnss,
|
||
tAudioCodec *audioCodec,
|
||
tLoggerInterface *logger,
|
||
tAtCmd *gsmAt,
|
||
|
||
tAudioPlayerInterface *audioPlayer,
|
||
tAudioRecorderInterface *audioRecorder,
|
||
|
||
tUserButtonsInterface *input,
|
||
tUserIndication *indication,
|
||
|
||
tEraGlonassUveos *ErGlUv,
|
||
bool *antMode,
|
||
tGpioPin *ring,
|
||
tPowerManagement *powerManagement,
|
||
|
||
tDeviceStorage *deviceStorage,
|
||
tDeviceModes *deviceModes,
|
||
tAmplifier *amplifier,
|
||
tModemDataColl *modemDataColl,
|
||
eQueryUDSState *queryUDSState,
|
||
float *boardVoltCalbCof,
|
||
bool *telematicaIsActive,
|
||
bool *fl_telematicaServerIsActive,
|
||
eDeviceTestingCode *deviceTestingCodeCan
|
||
) {
|
||
env->boardVoltCalbCof = boardVoltCalbCof;
|
||
env->audioHintsMode = HINTS_FULL;
|
||
env->queryUDSState = queryUDSState;
|
||
env->amplifier = amplifier;
|
||
env->modemDataColl = modemDataColl;
|
||
env->UserInputButtonWatcher = UserInputButtonWatcher;
|
||
env->logger = logger;
|
||
env->audioPlayer = audioPlayer;
|
||
env->audioRecorder = audioRecorder;
|
||
env->input = input;
|
||
env->indication = indication;
|
||
env->ErGlUv = ErGlUv;
|
||
env->accelDFI = &accel->accelDataFlow;
|
||
env->pinIgnition = ignPin;
|
||
env->ringPin = ring;
|
||
env->antDiscript.externalAdc = gnssAntAdc;
|
||
env->antDiscript.gsmAt = gsmAt;
|
||
env->antDiscript.mode = antMode;
|
||
env->gsmWithGnss = gsmWithGnss;
|
||
env->spekTestPower = spekTestPower;
|
||
env->powerManagement = powerManagement;
|
||
env->bipDiagnost = bipDiagnost;
|
||
env->deviceStorage = deviceStorage;
|
||
env->fl_oneTestResult = false;
|
||
env->telematicaIsActive = false;
|
||
env->systemExitStatus = SYSTEM_IS_FREE;
|
||
|
||
env->modemVersionRevisionTest.deviceModes = deviceModes;
|
||
env->modemVersionRevisionTest.modemDataCollector = modemDataColl;
|
||
env->modemVersionRevisionTest.deviceStorage = deviceStorage;
|
||
env->modemVersionRevisionTest.checkCert.isFind1 = false;
|
||
env->modemVersionRevisionTest.checkCert.isFind2 = false;
|
||
env->modemVersionRevisionTest.checkCert.isFind3 = false;
|
||
env->modemVersionRevisionTest.gsmWithGnss = gsmWithGnss;
|
||
env->modemVersionRevisionTest.telematicaIsActive = telematicaIsActive;
|
||
env->modemVersionRevisionTest.fl_telematicaServerIsActive = fl_telematicaServerIsActive;
|
||
env->modemVersionRevisionTest.testTelematicaIsActive = &env->telematicaIsActive;
|
||
|
||
env->canTest.deviceTestingCodeCan = deviceTestingCodeCan;
|
||
env->canTest.deviceStorage = deviceStorage;
|
||
env->canTest.fl_IsLoad = &env->modemVersionRevisionTest.modemDataCollector->fl_IsLoad;
|
||
|
||
env->mux_testingMode = osMutexNew(NULL);
|
||
|
||
DeviceTests_InitTestsTable(
|
||
env,
|
||
ignPin,
|
||
env->spekTestPower,
|
||
env->bipDiagnost,
|
||
batteryPower,
|
||
gsmAt,
|
||
audioCodec,
|
||
accel,
|
||
&env->antDiscript,
|
||
deviceStorage,
|
||
&env->modemVersionRevisionTest,
|
||
env->amplifier,
|
||
&env->canTest
|
||
);
|
||
|
||
InitThreadAtrStatic(&env->threadUserTest.attr, "Thread_UserTest", env->threadUserTest.controlBlock,
|
||
env->threadUserTest.stack, osPriorityNormal);
|
||
|
||
env->flagAutoTestSucsess = false;
|
||
env->flagAcsessExitThread = SYSTEM_IS_FREE;
|
||
return true;
|
||
}
|
||
|
||
void DeviceTesting_SetTelematicaTestMode(tDeviceTesting *env, bool mode) {
|
||
env->telematicaIsActive = mode;
|
||
}
|
||
|
||
void DeviceTesting_StartUserTestThread(tDeviceTesting *env) {
|
||
if (!env->threadUserTest.id) {
|
||
env->threadUserTest.id = osThreadNew(
|
||
(osThreadFunc_t) (DeviceTesting_ManualTestMode),
|
||
(void *) (env),
|
||
&env->threadUserTest.attr
|
||
);
|
||
}
|
||
}
|
||
|
||
bool DeviceTesting_ExitTestMode(tDeviceTesting *env) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Освобождение потока подсистемы тестирования")
|
||
uint32_t tm = SystemGetMs() + 8000;
|
||
while (tm > SystemGetMs()) {
|
||
if (osMutexAcquire(env->gsmWithGnss->gsmAt.access, 100) == osOK) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Блокировка АТ интерфейса снята")
|
||
if (osThreadTerminate(env->threadUserTest.id) == osOK) {
|
||
SystemDelayMs(10);
|
||
|
||
|
||
env->threadUserTest.id = NULL;
|
||
env->flagAcsessExitThread = SYSTEM_IS_FREE;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Поток подсистемы тестирования освобождён")
|
||
osMutexRelease(env->gsmWithGnss->gsmAt.access);
|
||
AudioRecord_StopToEndRec(env->audioRecorder, 1000);
|
||
|
||
return 1;
|
||
} else {
|
||
osMutexRelease(env->gsmWithGnss->gsmAt.access);
|
||
return 0;
|
||
}
|
||
}
|
||
SystemDelayMs(1);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void DeviceTesting_ChekExit(tDeviceTesting *env) {
|
||
SystemDelayMs(50);
|
||
EraGlonassUveos_DoNothingModeDistance(env->ErGlUv, false);
|
||
}
|
||
|
||
bool DeviceTesting_RunUserTests(tDeviceTesting *env) {
|
||
if (osMutexAcquire(env->mux_testingMode, 3000) == osOK) {
|
||
|
||
DeviceTesting_StartUserTestThread(env);
|
||
|
||
for (;;) {
|
||
|
||
if (env->flagAcsessExitThread == SYSTEM_IS_BUSY) {
|
||
// LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
// "!!!!SYSTEM_IS_BUSY!!!!!")
|
||
SystemDelayMs(400);
|
||
continue;
|
||
}
|
||
|
||
if (env->queryUDSState->commands == COM_STOP) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Попытка выхода из режима пользовательского тестирования, код 4")
|
||
if (DeviceTesting_ExitTestMode(env)) {
|
||
EraGlonassUveos_DoNotingReset(env->ErGlUv);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Автоматический выход из режима пользовательского тестирования, код 4")
|
||
env->queryUDSState->commands = COM_INIT;
|
||
osMutexRelease(env->mux_testingMode);
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
if (!GpioPinGet(env->pinIgnition) /*&& (env->flagAcsessExitThread == SYSTEM_IS_FREE)*/) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Попытка выхода из режима пользовательского тестирования, код 3")
|
||
if (DeviceTesting_ExitTestMode(env)) {
|
||
EraGlonassUveos_DoNotingReset(env->ErGlUv);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Автоматический выход из режима пользовательского тестирования, код 3")
|
||
osMutexRelease(env->mux_testingMode);
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
if (env->flagAcsessExitThread == SYSTEM_IS_DONE) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Попытка выхода из режима пользовательского тестирования, код 2")
|
||
if (DeviceTesting_ExitTestMode(env)) {
|
||
EraGlonassUveos_DoNotingReset(env->ErGlUv);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Автоматический выход из режима пользовательского тестирования, код 2")
|
||
osMutexRelease(env->mux_testingMode);
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
if (env->ErGlUv->doNothing.mode == UVEOS_DO_NOTHING_DISABLED) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Попытка выхода из режима пользовательского тестирования, код 1")
|
||
if (DeviceTesting_ExitTestMode(env)) {
|
||
EraGlonassUveos_DoNotingReset(env->ErGlUv);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Автоматический выход из режима пользовательского тестирования, код 1")
|
||
|
||
osMutexRelease(env->mux_testingMode);
|
||
return 1;
|
||
}
|
||
|
||
}
|
||
|
||
SystemDelayMs(400);
|
||
}
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления ( DeviceTesting_RunUserTests )");
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
void DeviceTesting_ManualTestMode(tDeviceTesting *env) {
|
||
//запускаем режим тестирования с пользователем
|
||
DeviceTesting_MainTestingMode(env);
|
||
}
|
||
|
||
//возвращает true в случае ошибки
|
||
bool DeviceTesting_OnIgnitionWithoutGsm(tDeviceTesting *env) {
|
||
DeviceTestsTable_TestInMode(&env->testsTable, DEVICE_TESTING_MODE_IGNITION_WITHOUT_GSM, 0);
|
||
return DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_ERROR);
|
||
}
|
||
|
||
//возвращает true в случае ошибки
|
||
bool DeviceTesting_OnIgnitionAfterGsm(tDeviceTesting *env) {
|
||
DeviceTestsTable_TestInMode(&env->testsTable, DEVICE_TESTING_MODE_IGNITION_AFTER_GSM, 0);
|
||
return DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_ERROR);
|
||
}
|
||
|
||
//возвращает true в случае ошибки
|
||
bool DeviceTesting_Always(tDeviceTesting *env) {
|
||
DeviceTestsTable_TestInMode(&env->testsTable, DEVICE_TESTING_MODE_ALWAYS, 100);
|
||
|
||
if ((DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_ERROR)) ||
|
||
(DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_NOT_CONNECTED)) ||
|
||
(DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_SHORT_CIRCUIT))
|
||
) {
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
//возвращает true в случае ошибки
|
||
bool DeviceTesting_Main(tDeviceTesting *env) {
|
||
DeviceTestsTable_TestInMode(&env->testsTable, DEVICE_TESTING_MODE_MAIN, 0);
|
||
return DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_ERROR);
|
||
}
|
||
|
||
|
||
//возвращает true в случае ошибки
|
||
bool DeviceTesting_Periodical(tDeviceTesting *env) {
|
||
if (!env->testsTable.currentProcessIterationsLeft) {
|
||
return false;
|
||
}
|
||
--env->testsTable.currentProcessIterationsLeft;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим самотестирования")
|
||
SystemDelayMs(5000);
|
||
DeviceTestsTable_TestInMode(&env->testsTable, DEVICE_TESTING_MODE_PERIODICAL, 1000);
|
||
bool errors = DeviceTestsTable_AnyTestHasCode(&env->testsTable, DEVICE_TESTING_CODE_ERROR);
|
||
|
||
if (errors) {
|
||
for (uint16_t testIdx = 0; testIdx < env->testsTable.count; ++testIdx) {
|
||
tTestDescriptor *test = env->testsTable.items + testIdx;
|
||
|
||
if (test->result == DEVICE_TESTING_CODE_ERROR) {
|
||
LoggerCnErrorStatic(LOGGER, LOG_SIGN, "Тест ")
|
||
LoggerCnError(LOGGER, LOG_SIGN, test->name.str, test->name.length)
|
||
LoggerErrorStatic(LOGGER, LOG_SIGN, " не пройден")
|
||
}
|
||
}
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Все тесты пройдены")
|
||
}
|
||
|
||
return errors;
|
||
}
|
||
|
||
bool DeviceTesting_UserTests(tDeviceTesting *env) {
|
||
DeviceTesting_ChekExit(env);
|
||
EraGlonassMsd_ClearDiagnostic(&env->tmsdDiagRes);
|
||
//задаем режим и обновляем индикторы
|
||
UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.uimFailure, DeviceTesting_Buttons(env));
|
||
DeviceTesting_ChekExit(env);
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.speakersFailure, DeviceTesting_TestAudioSpeaker(env));
|
||
DeviceTesting_ChekExit(env);
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.ignitionLineFailure, DeviceTesting_Ignition(env));
|
||
DeviceTesting_ChekExit(env);
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.micFailure, DeviceTesting_TestMic(env));
|
||
DeviceTesting_ChekExit(env);
|
||
|
||
//выключаем индикацию
|
||
UserIndication_StopThread(env->indication);
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.statusIndicatorFailure, DeviceTesting_Indication(env));
|
||
DeviceTesting_ChekExit(env);
|
||
//включаем индикацию
|
||
UserIndication_StartThread(env->indication);
|
||
return DeviceTesting_UserGetResult(env);
|
||
}
|
||
|
||
void DeviceTesting_GetSystemTest(tDeviceTesting *env) {
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
|
||
if (DeviceTestsTable_MakeTest(env->namedTests.firmware) == DEVICE_TESTING_CODE_PASSED) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Автоматическое тестирование целостности ПО, вызванн ое пользователем прошло успешно")
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.firmwareImageCorruption, false);
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("po_ok")
|
||
}
|
||
|
||
if (!env->flagAutoTestSucsess) {
|
||
env->flagAutoTestSucsess = true;
|
||
}
|
||
} else {
|
||
if (!env->flagAutoTestSucsess) {
|
||
env->flagAutoTestSucsess = false;
|
||
}
|
||
}
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
|
||
if (DeviceTestsTable_MakeTest(env->namedTests.gsm) != DEVICE_TESTING_CODE_PASSED) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка модема при автоматическом тестировании пользователем")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("modem_error.mp3.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.commModuleFailure, true);
|
||
if (env->flagAutoTestSucsess) {
|
||
env->flagAutoTestSucsess = false;
|
||
}
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Автоматическое тестирование модема, вызванное пользователем прошло успешно")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("modem_ok.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.commModuleFailure, false);
|
||
}
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
|
||
if (DeviceTestsTable_MakeTest(env->namedTests.accel) == DEVICE_TESTING_CODE_PASSED) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Автоматическое тестирование акселеромерта, вызванное пользователем прошло успешно")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("acsel_ok.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.crashSensorFailure, false);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка акселеромерта при автоматическом тестировании пользователем")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("acsel_error.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.crashSensorFailure, true);
|
||
if (env->flagAutoTestSucsess) {
|
||
env->flagAutoTestSucsess = false;
|
||
}
|
||
}
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
|
||
if (DeviceTestsTable_MakeTest(env->namedTests.batteryCharge) != DEVICE_TESTING_CODE_ERROR) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Автоматическое тестирование АКБ, вызванное пользователем прошло успешно")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("akb_ok.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.batteryFailure, false);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка АКБ при автоматическом тестировании пользователем")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("akb_error.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.batteryFailure, true);
|
||
if (env->flagAutoTestSucsess) {
|
||
env->flagAutoTestSucsess = false;
|
||
}
|
||
}
|
||
|
||
if (
|
||
(DeviceTestsTable_MakeTest(env->namedTests.gnssAnt) == DEVICE_TESTING_CODE_CONNECTED) ||
|
||
(DeviceTestsTable_MakeTest(env->namedTests.gnssAnt) == DEVICE_TESTING_CODE_INPUT_ANTENA_OK)
|
||
) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Автоматическое тестирование антенны, вызванное пользователем прошло успешно")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("ant_ok.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.gnssAntennaFailure, false);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка антенны при автоматическом тестировании пользователем")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("ant_error.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.gnssAntennaFailure, true);
|
||
if (env->flagAutoTestSucsess) {
|
||
env->flagAutoTestSucsess = false;
|
||
}
|
||
}
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
|
||
env->powerManagement->powerSusystem->SpekTestPower.speakTestAcsess = true;
|
||
if (DeviceTestsTable_MakeTest(env->namedTests.audioCodec) == DEVICE_TESTING_CODE_PASSED) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Автоматическое тестирование аудио тракта, вызванное пользователем прошло успешно")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("audioSub_ok.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.speakersFailure, false);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка аудио тракта при автоматическом тестировании пользователем")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("audioSub_error.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.speakersFailure, true);
|
||
if (env->flagAutoTestSucsess) {
|
||
env->flagAutoTestSucsess = false;
|
||
}
|
||
}
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
|
||
if (DeviceTestsTable_MakeTest(env->namedTests.bipConnect) == DEVICE_TESTING_CODE_CONNECTED) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN,
|
||
"Автоматическое тестирование подключения блока интерфейса пользователя выполнено успешно")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("bip_is_connect.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.uimFailure, false);
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка подключения блока интерфейса пользователя выполнено успешно")
|
||
if (env->audioHintsMode == HINTS_FULL) {
|
||
DEVTST_PLAY_SAMPLE("bip_is_not_connect.mp3")
|
||
}
|
||
|
||
EraGlonassMsd_OptionalFlagSet(env->tmsdDiagRes.uimFailure, true);
|
||
if (env->flagAutoTestSucsess) {
|
||
env->flagAutoTestSucsess = false;
|
||
}
|
||
}
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
|
||
if (env->audioHintsMode == HINTS_NORMAL) {
|
||
DEVTST_PLAY_SAMPLE("dataStateDevIsCollections.mp3")
|
||
}
|
||
}
|
||
|
||
void DeviceTesting_MainTestingStopMode(tDeviceTesting *env) {
|
||
env->flagAcsessExitThread = SYSTEM_IS_DONE;
|
||
uint32_t timer = SystemGetMs() + 20000;
|
||
while (1) {
|
||
if (timer < SystemGetMs()) {
|
||
// return;
|
||
}
|
||
SystemDelayMs(5000);
|
||
}
|
||
}
|
||
|
||
void DeviceTesting_RunInternalTests(tDeviceTesting *env) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Выполняются внутренние тесты")
|
||
DeviceTesting_GetSystemTest(env);
|
||
}
|
||
|
||
void DeviceTesting_AudioReportAsInternalTests(tDeviceTesting *env, bool userTestsOk) {
|
||
#if (AURUS_CAR_UI == 1)
|
||
if (env->flagAutoTestSucsess) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Внутренние тесты завершены успешно")
|
||
DEVTST_PLAY_SAMPLE("notError.mp3")
|
||
} else {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка внутреннего теста")
|
||
DEVTST_PLAY_SAMPLE("isError.mp3")
|
||
}
|
||
|
||
#endif
|
||
#if (AURUS_CAR_UI == 0)
|
||
if (env->flagAutoTestSucsess) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Внутренние тесты завершены успешно")
|
||
}
|
||
DeviceTesting_ChekExit(env);
|
||
if (userTestsOk && !env->flagAutoTestSucsess) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка внутреннего теста")
|
||
DEVTST_PLAY_SAMPLE("test_full_error.mp3")
|
||
}
|
||
#endif
|
||
|
||
}
|
||
|
||
bool DeviceTesting_RunTestCall(tDeviceTesting *env) {
|
||
|
||
bool result = false;
|
||
UserInputButtonWatcher_Clear(env->UserInputButtonWatcher);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Начало тестирования вызова с передачей данных с результатами проверки")
|
||
|
||
#if (AURUS_CAR_UI == 1)
|
||
DEVTST_PLAY_SAMPLE("testCoolUp.mp3")
|
||
#endif
|
||
#if (AURUS_CAR_UI == 0)
|
||
DEVTST_PLAY_SAMPLE("ecall_test.mp3")
|
||
#endif
|
||
|
||
env->flagAcsessExitThread = SYSTEM_IS_BUSY;
|
||
result = DeviceTesting_Ecall(env);
|
||
env->flagAcsessExitThread = SYSTEM_IS_FREE;
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Тестовый вызов пройден")
|
||
DeviceTesting_ChekExit(env);
|
||
|
||
|
||
#if (AURUS_CAR_UI == 0)
|
||
DeviceTesting_GetEcalRes(env);
|
||
#endif
|
||
|
||
|
||
if (env->ecallAddStatusRes == 1) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Выполняются вызов оператору 112")
|
||
env->ErGlUv->currentMsd->msd.MSD_Data.msgId = 1;
|
||
env->flagAcsessExitThread = SYSTEM_IS_BUSY;
|
||
if (EraGlonassUveos_ManualEmergencyCall(env->ErGlUv) == ERA_GLONASS_UVEOS_CALL_SUCCESS) {
|
||
result = true;
|
||
}
|
||
env->flagAcsessExitThread = SYSTEM_IS_FREE;
|
||
}
|
||
|
||
#if (AURUS_CAR_UI == 1)
|
||
if(result == true){
|
||
DEVTST_PLAY_SAMPLE("testCoolDoneTestingDone.mp3")
|
||
}
|
||
#endif
|
||
|
||
return result;
|
||
}
|
||
|
||
void DeviceTesting_MainTestingModeExitIsTimeOut(tDeviceTesting *env) {
|
||
if (
|
||
env->ErGlUv->timings.lastTestCall &&
|
||
(env->ErGlUv->timings.lastTestCall > SystemGetMs())
|
||
) {
|
||
env->queryUDSState->state = QUERY_ERROR;
|
||
DEVTST_PLAY_SAMPLE("tets_call_timeuot.mp3");
|
||
DeviceTesting_MainTestingStopMode(env);
|
||
}
|
||
}
|
||
|
||
bool DeviceTesting_GetNetworkReg(tGsmWithGnss *env) {
|
||
if (!GsmWithGnss_WaitNetworkRegistration(env, 1500)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Сеть или сим-чип отсутствует, попытка регистрации код 6");
|
||
if (GsmWithGnss_NetworkSetStateInnaterups(env, 4, 20000) == AT_OK) {
|
||
return true;
|
||
LoggerTraceStatic(LOGGER, LOG_SIGN, "Сеть присутствует")
|
||
} else {
|
||
LoggerErrorStatic(LOGGER, LOG_SIGN, "нет сети");
|
||
return false;
|
||
}
|
||
} else {
|
||
return true;
|
||
LoggerErrorStatic(LOGGER, LOG_SIGN, "Регистрация в сети присутствует");
|
||
}
|
||
}
|
||
|
||
bool DeviceTesting_TestingECool(tDeviceTesting *env) {
|
||
UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);
|
||
DeviceTesting_RunInternalTests(env);
|
||
DeviceTesting_ChekExit(env);
|
||
DeviceTesting_AudioReportAsInternalTests(env, true);
|
||
DeviceTesting_ChekExit(env);
|
||
|
||
bool res = DeviceTesting_RunTestCall(env);
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Голосовой отчёт по тестовому вызову выполнен")
|
||
return res;
|
||
}
|
||
|
||
void DeviceTesting_MainTestingMode(tDeviceTesting *env) {
|
||
// UserIndication_Uiu(env->indication, UIU_OFF);
|
||
|
||
UserButtons_Clear(env->input);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Начало пользовательского тестирования")
|
||
|
||
|
||
if (env->queryUDSState->source == REG_TO_NETWORK) {
|
||
UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);
|
||
// AtGsm_OperatorSelectionDeregister(&env->gsmWithGnss->gsmAt);
|
||
// SystemDelayMs(500);
|
||
// AtGsm_OperatorSelectionAutomatic(&env->gsmWithGnss->gsmAt);
|
||
// bool regRes = false;
|
||
// uint32_t tmt = SystemGetMs()+180000;
|
||
// while ( (regRes == false) || (tmt > SystemGetMs()) ) {
|
||
// regRes = true;//GsmWithGnss_WaitNetworkRegistration(env->gsmWithGnss, 1500);
|
||
// SystemDelayMs(1000);
|
||
// }
|
||
|
||
bool regRes = true;
|
||
if (regRes) {
|
||
env->queryUDSState->state = QUERY_DONE;
|
||
} else {
|
||
env->queryUDSState->state = QUERY_ERROR;
|
||
}
|
||
|
||
DeviceTesting_MainTestingStopMode(env);
|
||
return;
|
||
}
|
||
|
||
if (env->queryUDSState->source == REG_BOARD_VOLTAGE_CALIBRATION) {
|
||
UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);
|
||
bool calibRes = Adcs_SetCalibBoardVoltage(
|
||
env->powerManagement->powerSusystem->boardPower.boardVoltage,
|
||
env->boardVoltCalbCof
|
||
);
|
||
|
||
if (calibRes) {
|
||
EraGlonassUveosDumper_ForceDump(env->ErGlUv->dumper);
|
||
env->queryUDSState->state = QUERY_DONE;
|
||
} else {
|
||
env->queryUDSState->state = QUERY_ERROR;
|
||
}
|
||
DeviceTesting_MainTestingStopMode(env);
|
||
return;
|
||
}
|
||
|
||
if (env->queryUDSState->source == LEDS_TEST) {
|
||
eAudioHintsMode audioHintsModeTmp = env->audioHintsMode;
|
||
env->audioHintsMode = HINTS_MINIMAL;
|
||
|
||
UserIndication_StopThread(env->indication);
|
||
env->fl_oneTestResult = DeviceTesting_Indication(env);
|
||
UserIndication_StartThread(env->indication);
|
||
|
||
if (env->fl_oneTestResult == false) {
|
||
env->queryUDSState->state = QUERY_DONE;
|
||
} else {
|
||
env->queryUDSState->state = QUERY_ERROR;
|
||
}
|
||
|
||
env->audioHintsMode = audioHintsModeTmp;
|
||
DeviceTesting_MainTestingStopMode(env);
|
||
|
||
return;
|
||
}
|
||
|
||
if (env->queryUDSState->source == SPEAK_MICR_TEST) {
|
||
DEVTST_PLAY_SAMPLE("test_dinam_one.mp3")
|
||
//задаем режим и обновляем индикторы
|
||
UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);
|
||
env->fl_oneTestResult = DeviceTesting_TestMic(env);
|
||
|
||
if (env->fl_oneTestResult == false) {
|
||
env->queryUDSState->state = QUERY_DONE;
|
||
} else {
|
||
env->queryUDSState->state = QUERY_ERROR;
|
||
}
|
||
DeviceTesting_MainTestingStopMode(env);
|
||
|
||
return;
|
||
}
|
||
|
||
if (env->queryUDSState->source == ECALL_TEST) {
|
||
|
||
DeviceTesting_MainTestingModeExitIsTimeOut(env);
|
||
env->audioHintsMode = HINTS_NORMAL;
|
||
|
||
bool res = DeviceTesting_TestingECool(env);
|
||
env->audioHintsMode = HINTS_FULL;
|
||
if (res == true) {
|
||
env->queryUDSState->state = QUERY_DONE;
|
||
} else {
|
||
env->queryUDSState->state = QUERY_ERROR;
|
||
}
|
||
DeviceTesting_MainTestingStopMode(env);
|
||
return;
|
||
}
|
||
|
||
if (env->queryUDSState->source == ECALL_NOT_REG_TEST) {
|
||
DeviceTesting_MainTestingModeExitIsTimeOut(env);
|
||
env->audioHintsMode = HINTS_NORMAL;
|
||
UserIndication_SetMode(env->indication, DEVICE_MODE_TESTING);
|
||
DeviceTesting_RunInternalTests(env);
|
||
DeviceTesting_ChekExit(env);
|
||
DeviceTesting_AudioReportAsInternalTests(env, true);
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
DEVTST_PLAY_SAMPLE("not_reg_to_net.mp3")
|
||
bool res = DeviceTesting_RunTestCall(env);
|
||
DeviceTesting_ChekExit(env);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Голосовой отчёт по тестовому вызову выполнен")
|
||
env->audioHintsMode = HINTS_FULL;
|
||
if (res == true) {
|
||
env->queryUDSState->state = QUERY_DONE;
|
||
} else {
|
||
env->queryUDSState->state = QUERY_ERROR;
|
||
}
|
||
DeviceTesting_MainTestingStopMode(env);
|
||
return;
|
||
}
|
||
|
||
if (env->queryUDSState->source == FULL_TESTS) {
|
||
bool userTestsOk = DeviceTesting_UserTests(env);
|
||
DeviceTesting_RunInternalTests(env);
|
||
DeviceTesting_ChekExit(env);
|
||
DeviceTesting_AudioReportAsInternalTests(env, userTestsOk);
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
if (userTestsOk && env->flagAutoTestSucsess) {
|
||
if (!DeviceTesting_Main(env)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Все тесты пройдены успешно")
|
||
DEVTST_PLAY_SAMPLE("test_full_ok.mp3")
|
||
}
|
||
}
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
DeviceTesting_RunTestCall(env);
|
||
DeviceTesting_ChekExit(env);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Голосовой отчёт по тестовому вызову выполнен")
|
||
|
||
DeviceTesting_MainTestingStopMode(env);
|
||
}
|
||
|
||
if (env->queryUDSState->source == INTERNAL_ONE_TEST) {
|
||
|
||
eAudioHintsMode audioHintsMode = env->audioHintsMode;
|
||
env->audioHintsMode = HINTS_NONE;
|
||
DeviceTesting_RunInternalTests(env);
|
||
|
||
DeviceTesting_ChekExit(env);
|
||
DeviceTesting_AudioReportAsInternalTests(env, NULL);
|
||
DeviceTesting_ChekExit(env);
|
||
|
||
env->fl_oneTestResult = DeviceTesting_TestSpeakMic(env);
|
||
|
||
if ((env->flagAutoTestSucsess)&&(!env->fl_oneTestResult)) {
|
||
if (!DeviceTesting_Main(env)) {
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Все тесты пройдены успешно")
|
||
}
|
||
}
|
||
|
||
if(env->gsmWithGnss->gnss.currentRmc.status != 'A') {
|
||
DEVTST_PLAY_SAMPLE("satelitNone.mp3")
|
||
}
|
||
|
||
DeviceTesting_RunTestCall(env);
|
||
DeviceTesting_ChekExit(env);
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Голосовой отчёт по тестовому вызову выполнен")
|
||
|
||
env->audioHintsMode = audioHintsMode;
|
||
DeviceTesting_MainTestingStopMode(env);
|
||
}
|
||
}
|