Smart_Components_Aurus
/
SMART_COMPONENTS_ModemDataCollector
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 7c1f5d0da8
4 changed files with 512 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
IncRemapCollect.h Normal file
View File

@ -0,0 +1,8 @@
//
// Created by zemon on 27.02.25.
//
#ifndef SMART_COMPONENTS_V2_INCREMAPCOLLECT_H
#define SMART_COMPONENTS_V2_INCREMAPCOLLECT_H
#include "SystemSelector.h"
#endif //SMART_COMPONENTS_V2_INCREMAPCOLLECT_H

422
ModemDataCollector.c Normal file
View File

@ -0,0 +1,422 @@
#include <stddef.h>
#include <memory.h>
#include "ModemDataCollector.h"
#include "BaseTypes/Strings.h"
#include "AtCmdBase.h"
//#include "AtCmdCommonProtected.h"
#include "VariablesTable.h"
#include "DeviceStorage.h"
#include "SystemDelayInterface.h"
#include "AtGsmSimComA7600_SSL_LOAD_CA.h"
//#include "PowerManagment.h"
//
// Created by zemon on 28.08.24.
//
#define LOG_SIGN "Сборщик данных модема"
#define LOGGER env->logger
void ModemDataCollectorItit(
tModemDataColl *env,
tSim7600ePower *sim7600ePower,
tLoggerInterface *logger,
tAtCmd *gsmAt,
tDeviceStorage *storage,
tSystemSelector *systemSelector
) {
env->modemVersionRevision.validAudio = MOD_ERROR;
env->modemVersionRevision.sertRevision.validSert = MOD_ERROR;
env->modemVersionRevision.modemStateIsValid = false;
env->fl_IsLoad = false;
env->modemVersionRevision.valid_CCID = MOD_UNDEFANDED;
env->modemVersionRevision.valid_CCIDComer = MOD_UNDEFANDED;
env->logger = logger;
env->gsmAt = gsmAt;
env->storage = storage;
env->sim7600ePower = sim7600ePower;
env->systemSelector = systemSelector;
tVariableDescriptor *var;
env->modemVersionRevision.resIsChipSelect = false;
env->timeIsTestModemLimit = SystemGetMs() + 60000;
var = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_SIM_PROFILE");
if (var->len) {
env->simProfile.length = var->len;
env->simProfile.data = var->addr;
}
}
// окерпичиватель модема
void ModemDataCollector_ModemFlashing(tModemDataColl *env) {
env->storage->nvm->device.factoryMode = true;
EraGlonassUveosDumper_ForceDump(&env->storage->uveosDumper);
AtGsm_Gsnss_Simcom7600_GnssStopThread(env->gsmAt);
LoggerInfoStatic(LOGGER, LOG_SIGN,
"Инициализирован повторный переход в режим производственного контроля, команда получена по UDS")
}
void ModemDataCollector_GeIds(tModemDataColl *env) {
tVariableDescriptor *var;
if (env->sim7600ePower->thisSimChip == CHIP_ERA) {
var = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_CCID");
} else {
var = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_CCID_COMERS");
}
if (var->len) {
tStringLink idValueIsStorage = {
.length = var->len,
.data = var->addr
};
size_t length;
AtCommandResult resIds_readIdEra = AT_ERROR;
AtCommandResult resIds_readIdComers = AT_ERROR;
if (osMutexAcquire(env->gsmAt->access, 4000) == osOK) {
if (env->sim7600ePower->thisSimChip == CHIP_ERA) {
resIds_readIdEra = AtGsm_Gsnss_Simcom7600_GetCCID(env->gsmAt, env->modemVersionRevision.ssidValue.data,
&length);
env->modemVersionRevision.ssidValue.length = length;
} else {
resIds_readIdComers = AtGsm_Gsnss_Simcom7600_GetCCID(env->gsmAt,
env->modemVersionRevision.ssidComersValue.data,
&length);
env->modemVersionRevision.ssidComersValue.length = length;
}
osMutexRelease(env->gsmAt->access);
} else {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления Mma_GetCGSN_1")
}
if (var->len) {
if (env->sim7600ePower->thisSimChip == CHIP_ERA) {
if (resIds_readIdEra == AT_OK) {
if (
(memcmp(env->modemVersionRevision.ssidValue.data, idValueIsStorage.data, length) != 0) ||
(env->modemVersionRevision.ssidValue.length != *idValueIsStorage.length)
) {
memcpy(idValueIsStorage.data, env->modemVersionRevision.ssidValue.data, length);
*idValueIsStorage.length = length;
env->modemVersionRevision.ssidValue.length = length;
DeviceStorage_DelayedDump(env->storage);
}
env->modemVersionRevision.valid_CCID = MOD_READY;
} else {
length = 19;
if (
(memcmp(idValueIsStorage.data, "1111111111111111111", length) == 0) &&
(*idValueIsStorage.length == length)
) {
memcpy(env->modemVersionRevision.ssidValue.data, idValueIsStorage.data, length);
env->modemVersionRevision.ssidValue.length = length;
env->modemVersionRevision.valid_CCID = MOD_ERROR;
return;
} else {
memcpy(idValueIsStorage.data, "1111111111111111111", length);
memcpy(env->modemVersionRevision.ssidValue.data, idValueIsStorage.data, length);
*idValueIsStorage.length = length;
env->modemVersionRevision.ssidValue.length = length;
env->modemVersionRevision.valid_CCID = MOD_ERROR;
DeviceStorage_DelayedDump(env->storage);
}
}
}
if (env->sim7600ePower->thisSimChip == CHIP_COMERS) {
env->modemVersionRevision.ssidComersValue.length = length;
if (resIds_readIdComers == AT_OK) {
if (
(memcmp(env->modemVersionRevision.ssidComersValue.data, idValueIsStorage.data, length) !=
0) ||
(env->modemVersionRevision.ssidComersValue.length != *idValueIsStorage.length)
) {
*idValueIsStorage.length = length;
memcpy(idValueIsStorage.data, env->modemVersionRevision.ssidComersValue.data, length);
env->modemVersionRevision.ssidComersValue.length = length;
DeviceStorage_DelayedDump(env->storage);
}
env->modemVersionRevision.valid_CCIDComer = MOD_READY;
} else {
length = 20;
if (
(memcmp(idValueIsStorage.data, "1111111111111111111", length) == 0) &&
(*idValueIsStorage.length == 20)
) {
memcpy(env->modemVersionRevision.ssidComersValue.data, idValueIsStorage.data, length);
env->modemVersionRevision.ssidComersValue.length = length;
env->modemVersionRevision.valid_CCIDComer = MOD_ERROR;
return;
} else {
memcpy(idValueIsStorage.data, "1111111111111111111", length);
memcpy(env->modemVersionRevision.ssidComersValue.data, idValueIsStorage.data, length);
*idValueIsStorage.length = length;
env->modemVersionRevision.ssidComersValue.length = length;
env->modemVersionRevision.valid_CCIDComer = MOD_ERROR;
DeviceStorage_DelayedDump(env->storage);
}
}
}
}
}
}
void ModemDataCollector_GetCGSN(tModemDataColl *env) {
tVariableDescriptor *var = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_CGSN");
if (var->len) {
tStringLink cgsmidValueStorage = {
.length = var->len,
.data = var->addr
};
size_t length;
AtCommandResult resGetCGSN = AT_ERROR;
if (osMutexAcquire(env->gsmAt->access, 2000) == osOK) {
resGetCGSN = AtGsm_Gsnss_Simcom7600_GetCGSN(env->gsmAt, env->modemVersionRevision.cgsmValue.data, &length);
osMutexRelease(env->gsmAt->access);
} else {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления Mma_GetCGSN_4")
}
if (var->len) {
if (resGetCGSN == AT_OK) {
env->modemVersionRevision.cgsmValue.length = length;
if (
(memcmp(env->modemVersionRevision.cgsmValue.data, cgsmidValueStorage.data, length) != 0) ||
(env->modemVersionRevision.cgsmValue.length != *cgsmidValueStorage.length)
) {
memcpy(cgsmidValueStorage.data, env->modemVersionRevision.cgsmValue.data, length);
*cgsmidValueStorage.length = length;
env->modemVersionRevision.cgsmValue.length = length;
DeviceStorage_DelayedDump(env->storage);
}
} else {
length = 20;
if (
(memcmp(cgsmidValueStorage.data, "1111111111111111111", length) == 0) &&
(*cgsmidValueStorage.length == 20)
) {
memcpy(env->modemVersionRevision.cgsmValue.data, cgsmidValueStorage.data, length);
env->modemVersionRevision.cgsmValue.length = length;
return;
} else {
memcpy(cgsmidValueStorage.data, "1111111111111111111", length);
memcpy(env->modemVersionRevision.cgsmValue.data, cgsmidValueStorage.data, length);
*cgsmidValueStorage.length = length;
env->modemVersionRevision.cgsmValue.length = length;
DeviceStorage_DelayedDump(env->storage);
}
}
}
}
}
bool DeviceTesting_ValidAsCerts(tIsFind *env) {
if ((env->isFind1) &&
(env->isFind2) &&
(env->isFind3)
) {
return true;
} else {
return false;
}
}
void ModemDataCollector_GetSertRev(tModemDataColl *env) {
if (!DeviceTesting_ValidAsCerts(&env->modemVersionRevision.sertRevision.checkCert)) {
if (osMutexAcquire(env->gsmAt->access, 500) == osOK) {
env->modemVersionRevision.sertRevision.checkCert = AtGsmSimComA7600_SSL_CHECK_CA(env->gsmAt,
"ca.pem",
sizeof("ca.pem") - 1,
"crt.pem",
sizeof("crt.pem") - 1,
"key.pem",
sizeof("key.pem") - 1,
500);
osMutexRelease(env->gsmAt->access);
if (DeviceTesting_ValidAsCerts(&env->modemVersionRevision.sertRevision.checkCert)) {
env->modemVersionRevision.sertRevision.validSert = MOD_READY;
} else {
env->modemVersionRevision.sertRevision.validSert = MOD_ERROR;
}
} else {
env->modemVersionRevision.sertRevision.validSert = MOD_UNDEFANDED;
}
} else {
env->modemVersionRevision.sertRevision.validSert = MOD_READY;
}
}
void ModemDataCollector_GetAudioRev(tModemDataColl *env) {
AtCommandResult resGetCgmr;
if (env->modemVersionRevision.validAudio != MOD_READY) {
if (osMutexAcquire(env->gsmAt->access, 500) == osOK) {
resGetCgmr = AtGsm_Gsnss_Simcom7600_GetAudioFilesValidation(env->gsmAt);
osMutexRelease(env->gsmAt->access);
if (resGetCgmr == AT_OK) {
env->modemVersionRevision.validAudio = MOD_READY;
return;
}
if (resGetCgmr == AT_TIMEOUT) {
env->modemVersionRevision.validAudio = MOD_UNDEFANDED;
}
if (resGetCgmr == AT_ERROR) {
env->modemVersionRevision.validAudio = MOD_ERROR;
return;
}
} else {
env->modemVersionRevision.validAudio = MOD_UNDEFANDED;
}
}
}
void ModemDataCollector_GetSoftRev(tModemDataColl *env) {
AtCommandResult resGetCgmr = AT_ERROR;
tString32 cgmrValue;
size_t length;
if (osMutexAcquire(env->gsmAt->access, 2000) == osOK) {
resGetCgmr = AtGsm_Gsnss_Simcom7600_GetSoftRevInModem(env->gsmAt, cgmrValue.data, &length);
osMutexRelease(env->gsmAt->access);
} else {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка захвата управления Mma_GetCGSN_5")
}
if (resGetCgmr == AT_OK) {
if (length > 32) {
length = 32;
}
memcpy(env->modemVersionRevision.softValue.data, cgmrValue.data, length);
env->modemVersionRevision.softValue.length = length;
// Сравнение с версией в storage
if (((length != env->storage->nvm->modemSaveDeviceSoftVers.length) ||
(memcmp(cgmrValue.data, env->storage->nvm->modemSaveDeviceSoftVers.data,
cgmrValue.length) != 0))) {
env->storage->nvm->modemSaveDeviceSoftVers.length = length;
memcpy(env->storage->nvm->modemSaveDeviceSoftVers.data, cgmrValue.data, cgmrValue.length);
DeviceStorage_DelayedDump(env->storage);
}
}
}
bool ModemDataCollector_ChekSelectSimChips(tModemDataColl *env, const eSubSystems *subSystems) {
if (*subSystems == UNDEFANDET) {
ModemDataCollector_SetThisSubSystem(env->systemSelector, UNDEFANDET);
return false;
}
tString32 ssidValueThis;
size_t length;
if (*subSystems == TELEMATICA) {
if (env->modemVersionRevision.valid_CCIDComer == MOD_READY) {
if (osMutexAcquire(env->gsmAt->access, 4000) == osOK) {
if (AtGsm_Gsnss_Simcom7600_GetCCID(env->gsmAt, ssidValueThis.data, &length) == AT_OK) {
if (
(memcmp(env->modemVersionRevision.ssidComersValue.data, ssidValueThis.data, length) == 0) ||
(env->modemVersionRevision.ssidComersValue.length == length)
) {
osMutexRelease(env->gsmAt->access);
return true;
} else {
osMutexRelease(env->gsmAt->access);
return false;
}
} else {
osMutexRelease(env->gsmAt->access);
return false;
}
}
} else {
return false;
}
} else if (*subSystems == UVEOS) {
if (env->modemVersionRevision.valid_CCID == MOD_READY) {
if (osMutexAcquire(env->gsmAt->access, 4000) == osOK) {
if (AtGsm_Gsnss_Simcom7600_GetCCID(env->gsmAt, ssidValueThis.data, &length) == AT_OK) {
if (
(memcmp(env->modemVersionRevision.ssidValue.data, ssidValueThis.data, length) == 0) ||
(env->modemVersionRevision.ssidValue.length == length)
) {
osMutexRelease(env->gsmAt->access);
return true;
} else {
osMutexRelease(env->gsmAt->access);
return false;
}
} else {
osMutexRelease(env->gsmAt->access);
return false;
}
}
} else {
return false;
}
}
return false;
}
void ModemDataCollector_ChekReadSimChips(tModemDataColl *env) {
tVariableDescriptor *GSM_CCID;
tVariableDescriptor *GSM_CCID_COMERS;
GSM_CCID = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_CCID");
GSM_CCID_COMERS = VariablesTable_GetByNameStatic(&env->storage->publicVariablesTable, "GSM_CCID_COMERS");
if (
(memcmp(GSM_CCID->addr, GSM_CCID_COMERS->addr, *(uint8_t *) GSM_CCID->len) == 0) &&
(
(*(uint8_t *) GSM_CCID->len == *(uint8_t *) GSM_CCID_COMERS->len)
)
) {
uint8_t lenghtEra = sizeof("1111111111111111111");
uint8_t lenghtComers = sizeof("1111111111111111111");
memcpy(env->modemVersionRevision.ssidValue.data, "1111111111111111111", lenghtEra);
env->modemVersionRevision.ssidValue.length = lenghtEra;
memcpy(env->modemVersionRevision.ssidComersValue.data, "1111111111111111111", lenghtComers);
env->modemVersionRevision.ssidComersValue.length = lenghtComers;
memcpy(GSM_CCID->addr, "1111111111111111111", lenghtEra);
memcpy(GSM_CCID_COMERS->addr, "1111111111111111111", lenghtComers);
DeviceStorage_DelayedDump(env->storage);
env->modemVersionRevision.valid_CCIDComer = MOD_ERROR;
env->modemVersionRevision.valid_CCID = MOD_ERROR;
}
}
void ModemDataCollector_GetCCIDS(tModemDataColl *env) {
SystemDelayMs(500);
ModemDataCollector_SelectionSimChip(env->systemSelector, CHIP_ERA);
SystemDelayMs(500);
ModemDataCollector_GeIds(env);
SystemDelayMs(500);
ModemDataCollector_SelectionSimChip(env->systemSelector, CHIP_COMERS);
SystemDelayMs(500);
ModemDataCollector_GeIds(env);
ModemDataCollector_ChekReadSimChips(env);
}

72
ModemDataCollector.h Normal file
View File

@ -0,0 +1,72 @@
//
// Created by zemon on 28.08.24.
//
#ifndef SMART_COMPONENTS_MODEMDATACOLLECTOR_H
#define SMART_COMPONENTS_MODEMDATACOLLECTOR_H
#include "GsmWithGnss.h"
#include "LoggerToSerialPort.h"
#include "PwmSim7600e.h"
#include "AtGsmSimComA7600_SSL_LOAD_CA.h"
#include "IncRemapCollect.h"
typedef enum {
MOD_UNDEFANDED = 0,
MOD_ERROR = 1,
MOD_READY = 2,
}eValidCCID;
typedef struct {
eValidCCID validSert;
tIsFind checkCert;
} tSertRevision;
typedef struct {
bool resIsChipSelect;
tString32 softValue;
tString32 ssidValue;
tString32 ssidComersValue;
tString32 cgsmValue;
bool modemStateIsValid;
eValidCCID valid_CCID;
eValidCCID valid_CCIDComer;
tSertRevision sertRevision;
eValidCCID validSert;
eValidCCID validAudio;
uint16_t *deviceTestFix_ModemAudioFileValidation;
uint16_t *deviceTestFix_ModemCertValidation;
uint16_t *deviceTestFix_ModemValidation;
} tVersionRevision;
typedef struct {
tSim7600ePower *sim7600ePower;
tLoggerInterface *logger;
tAtCmd *gsmAt;
tDeviceStorage *storage;
tVersionRevision modemVersionRevision;
tSystemSelector *systemSelector;
tStringLink simProfile;
bool fl_IsLoad;
uint32_t timeIsTestModemLimit;
} tModemDataColl;
void ModemDataCollectorItit(
tModemDataColl *env,
tSim7600ePower *sim7600ePower,
tLoggerInterface *logger,
tAtCmd *gsmAt,
tDeviceStorage *storage,
tSystemSelector *systemSelector
);
void ModemDataCollector_GetCCIDS(tModemDataColl *env);
void ModemDataCollector_GetCGSN(tModemDataColl *env);
void ModemDataCollector_GetSoftRev(tModemDataColl *env);
void ModemDataCollector_GetSertRev(tModemDataColl *env);
void ModemDataCollector_GetAudioRev(tModemDataColl *env);
void ModemDataCollector_ModemFlashing(tModemDataColl *env);
bool ModemDataCollector_ChekSelectSimChips(tModemDataColl *env, const eSubSystems *subSystems);
#endif //SMART_COMPONENTS_MODEMDATACOLLECTOR_H

10
modular.json Normal file
View File

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