Smart_Components_Aurus
/
SMART_COMPONENTS_MainModesArbiter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Init

This commit is contained in:
cfif 2025-06-02 13:26:39 +03:00
commit 6a9b582509
11 changed files with 3904 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

444
InfoSystemToUDS.c Normal file
View File

@ -0,0 +1,444 @@
//
// Created by zemon on 21.08.24.
//
#include <math.h>
#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
);
}
}

1633
MainModesArbiter.c Normal file
View File

File diff suppressed because it is too large Load Diff

188
MainModesArbiter.h Normal file
View File

@ -0,0 +1,188 @@
//
// Created by xemon on 19.09.22.
//
#ifndef SMART_COMPONENTS_MAINMODESARBITER_H
#define SMART_COMPONENTS_MAINMODESARBITER_H
#include <stdbool.h>
#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 <EraGlonassUveos.h>
#include <PowerManagment.h>
#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

239
MainModesArbiter_Ecalls.c Normal file
View File

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

76
MainModesArbiter_EgtsSms.c Normal file
View File

@ -0,0 +1,76 @@
//
// Created by xemon on 09.01.23.
//
#include "MainModesArbiter_Private.h"
#include <AtGsmSms_Utils.h>
#define LOG_SIGN "Главн. sms"
#define LOGGER &env->slog.logger
void Mma_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;
}

1143
MainModesArbiter_InitStage.c Normal file
View File

File diff suppressed because it is too large Load Diff

122
MainModesArbiter_Private.h Normal file
View File

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

16
PeripheralInterfaces.c Normal file
View File

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

18
PeripheralInterfaces.h Normal file
View File

@ -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 <Gpios.h>
#include <Adcs.h>
#include <SerialPorts.h>
#include <I2cPorts.h>
#include <SpiPorts.h>
#include <StorageOnFlash.h>
#include "CanPorts.h"
void InitPeripheralInterfaces();
#endif //UVEOS_ON_NATION_DEVICE_PERIPHERALINTERFACES_H

15
TelematicaConnectStatus.h Normal file
View File

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

10
modular.json Normal file
View File

@ -0,0 +1,10 @@
{
"cmake": {
"inc_dirs": [
"./"
],
"srcs": [
"./**.c"
]
}
}