246 lines
8.9 KiB
C
246 lines
8.9 KiB
C
//
|
|
// Created by cfif on 05.06.2024.
|
|
//
|
|
#ifdef UVEOS_ADD_TELEMATICA
|
|
|
|
#include <math.h>
|
|
#include "Network.h"
|
|
#include "EgtsOutputCommands.h"
|
|
#include "SystemDelayInterface.h"
|
|
#include "AtGsmQuerySignalQuality.h"
|
|
#include "AtGsmGNSS.h"
|
|
#include "n32g45x_can.h"
|
|
|
|
#define LOG_SIGN "EGTS_INFO"
|
|
#define LOGGER &env->slog->logger
|
|
|
|
uint8_t QuerySignalQuality(tEgtsProcessing *env) {
|
|
|
|
uint8_t rssi = 0;
|
|
|
|
if (osMutexAcquire(env->gsm->gsmAt.access, 2000) == osOK) {
|
|
|
|
AtGsm_QuerySignalQuality(
|
|
&env->gsm->gsmAt,
|
|
&rssi
|
|
);
|
|
|
|
osMutexRelease(env->gsm->gsmAt.access);
|
|
} else {
|
|
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (QuerySignalQuality)")
|
|
}
|
|
|
|
return rssi;
|
|
}
|
|
|
|
void ResetGPS(tEgtsProcessing *env) {
|
|
if (osMutexAcquire(env->gsm->gsmAt.access, 5000) == osOK) {
|
|
AtGsm_ReceiverGnssResetColdstart(&env->gsm->gsmAt);
|
|
osMutexRelease(env->gsm->gsmAt.access);
|
|
} else {
|
|
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ошибка доступа (ResetGPS)")
|
|
}
|
|
}
|
|
|
|
void calc_driver_scoring(tCanMainAdditional *env, float new_speed) {
|
|
|
|
if (!env->gnss_config.acc_calc_time)
|
|
return;
|
|
|
|
if ((env->EngineSpeed > 100) && (new_speed >= (float) env->gnss_config.gnss_course_speed) &&
|
|
(env->calc_scoring.old_speed >= (float) env->gnss_config.gnss_course_speed)) {
|
|
float acc_sum = 0;
|
|
float coef_acc = 1.0f;
|
|
|
|
if (env->gnss_config.reference_speed && new_speed > ((float) env->gnss_config.reference_speed))
|
|
coef_acc = (float) sqrt((double) new_speed / ((double) env->gnss_config.reference_speed));
|
|
|
|
env->calc_scoring.acc_last[env->calc_scoring.index] = ((new_speed - env->calc_scoring.old_speed) * coef_acc);
|
|
|
|
for (uint32_t i = 0; i < env->gnss_config.acc_calc_time; i++) {
|
|
acc_sum += env->calc_scoring.acc_last[i];
|
|
}
|
|
|
|
if ((float) env->gnss_config.diff_speed_up > 0.0f && acc_sum >= (float) env->gnss_config.diff_speed_up) {
|
|
env->state_get.trip_acceleration++;
|
|
env->bc_get.total_acceleration++;
|
|
env->bc_get.acceleration++;
|
|
for (int i = 0; i < NUM_ACC_COUNT_MAX; i++) {
|
|
env->calc_scoring.acc_last[i] = 0.0f;
|
|
}
|
|
} else if ((float) env->gnss_config.diff_speed_down > 0.0f &&
|
|
acc_sum <= ((-1.0f) * (float) env->gnss_config.diff_speed_down)) {
|
|
env->state_get.trip_braking++;
|
|
env->bc_get.total_braking++;
|
|
env->bc_get.braking++;
|
|
for (int i = 0; i < NUM_ACC_COUNT_MAX; i++) {
|
|
env->calc_scoring.acc_last[i] = 0.0f;
|
|
}
|
|
}
|
|
|
|
if ((++env->calc_scoring.index) > (env->gnss_config.acc_calc_time - 1))
|
|
env->calc_scoring.index = 0;
|
|
|
|
env->calc_scoring.data_erase = false;
|
|
} else if (!env->calc_scoring.data_erase) {
|
|
for (int i = 0; i < NUM_ACC_COUNT_MAX; i++) {
|
|
env->calc_scoring.acc_last[i] = 0.0f;
|
|
}
|
|
env->calc_scoring.index = 0;
|
|
env->calc_scoring.data_erase = true;
|
|
}
|
|
env->calc_scoring.old_speed = new_speed;
|
|
}
|
|
|
|
void _Noreturn EgtsProcessing_InfoTask(tEgtsProcessing *env) {
|
|
// env->state_get
|
|
uint32_t timeOutCheckNetworkStatus = 0;
|
|
uint32_t timeNavUpdate = 0;
|
|
char status = 'V';
|
|
uint32_t timeStampCheck = 0;
|
|
uint32_t tm = 0;
|
|
bool oneOn = true;
|
|
bool oneOff = true;
|
|
bool bl = false;
|
|
double volatile EngineOXTemperature;
|
|
float realSpeed = 0;
|
|
uint8_t fuelLevel;
|
|
while (1) {
|
|
EngineOXTemperature = env->canData->engineOXTemperature * 0.75 - 48;
|
|
|
|
if (onOffTelematica(env, &oneOn, &oneOff, "Задача информации"))
|
|
continue;
|
|
|
|
if (osMutexAcquire(env->gsm->gsmAt.access, 1000) == osOK) {
|
|
AtGsm_Gsnss_GetNMEA_Pack(env->gsm, 400);
|
|
osMutexRelease(env->gsm->gsmAt.access);
|
|
|
|
///---начало------------------------------------Проверка навигации на сбой приемника------------------------------------
|
|
if (timeNavUpdate < SystemGetMs()) {
|
|
timeNavUpdate = SystemGetMs() + 10000;
|
|
|
|
tNmeaRmc nmeaRmc;
|
|
Gnss_GetFullNavData(env->gsm, &nmeaRmc);
|
|
|
|
uint32_t timestamp = iNmea0183TimestampFromRmc(&nmeaRmc);
|
|
|
|
if (nmeaRmc.status == 'A') {
|
|
|
|
if (timeStampCheck == timestamp) {
|
|
ResetGPS(env);
|
|
LoggerInfoStatic(LOGGER, LOG_SIGN, "Обнаружена остановка времени навигации")
|
|
timeStampCheck = 0;
|
|
} else {
|
|
timeStampCheck = timestamp;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
} else {
|
|
LoggerTraceStatic(LOGGER, LOG_SIGN, "Ошибка доступа (EgtsProcessing_InfoTask)")
|
|
}
|
|
|
|
|
|
if (tm < SystemGetMs()) {
|
|
if (EngineOXTemperature < 100) {
|
|
EngineOXTemperature++;
|
|
} else {
|
|
EngineOXTemperature = 0;
|
|
}
|
|
if (env->state_get.trip_acceleration < 10) {
|
|
env->state_get.trip_acceleration++;
|
|
} else {
|
|
env->state_get.trip_acceleration = 0;
|
|
}
|
|
if (env->state_get.trip_braking < 20) {
|
|
env->state_get.trip_braking++;
|
|
} else {
|
|
env->state_get.trip_braking = 0;
|
|
}
|
|
|
|
if (realSpeed < 300) {
|
|
fuelLevel++;
|
|
realSpeed = realSpeed * 0.01f;
|
|
} else {
|
|
fuelLevel = 0;
|
|
realSpeed = realSpeed * 0.01f;
|
|
}
|
|
|
|
if (fuelLevel < 80) {
|
|
fuelLevel++;
|
|
} else {
|
|
fuelLevel = 0;
|
|
}
|
|
|
|
if (env->canData->externalTemperature < 10) {
|
|
env->canData->externalTemperature++;
|
|
} else {
|
|
env->canData->externalTemperature = 0;
|
|
}
|
|
|
|
if (env->canData->engineSpeed < 500) {
|
|
env->canData->engineSpeed++;
|
|
} else {
|
|
env->canData->engineSpeed = 110;
|
|
}
|
|
|
|
tm = SystemGetMs() + 5000;
|
|
}
|
|
|
|
if (env->timeAbsSpeedOnSecond < SystemGetMs()) {
|
|
env->timeAbsSpeedOnSecond = SystemGetMs() + 1000;
|
|
|
|
double FuelLevel = fuelLevel * 0.5;
|
|
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_FuelLevel].value = (uint8_t) (FuelLevel /
|
|
0.5);
|
|
|
|
calc_driver_scoring(env->canMainAdditional, realSpeed);
|
|
|
|
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_ANS4].value = env->canData->engineSpeed;
|
|
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_ANS5].value = (uint32_t) realSpeed;
|
|
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_NumberAccelerations].value = env->state_get.trip_acceleration;
|
|
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_NumberBraking].value = env->state_get.trip_braking;
|
|
|
|
if (env->canData->externalTemperature != 0xFF) {
|
|
double ExternalTemperature = env->canData->externalTemperature * 1.0 - 40;
|
|
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_ExternalTemperature].value = (uint16_t) (
|
|
(ExternalTemperature + 40) / 0.5);
|
|
|
|
}
|
|
|
|
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_Uptime].value =
|
|
SystemGetMs() / 60000; // Uptime
|
|
|
|
if (EngineOXTemperature < -39.5) {
|
|
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_EngineOXTemperature].value = 0;
|
|
} else {
|
|
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_EngineOXTemperature].value = (uint16_t) (
|
|
(EngineOXTemperature + 40) / 0.5);
|
|
}
|
|
|
|
// По умолчанию в SLEEP, до этого было в TS_STATUS_STANDBY
|
|
eEgtsTsStatus SENSORS_AN_VehicleStatus_loc = TS_STATUS_SLEEP;
|
|
|
|
// Поднят пин зажигания
|
|
if (GpioPinGet(env->ignition)) {
|
|
SENSORS_AN_VehicleStatus_loc = TS_STATUS_IGNITION;
|
|
|
|
} else {
|
|
}
|
|
|
|
// Установка значения сенсора состояния
|
|
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_VehicleStatus].value = SENSORS_AN_VehicleStatus_loc;
|
|
|
|
if (timeOutCheckNetworkStatus < SystemGetMs()) {
|
|
timeOutCheckNetworkStatus = SystemGetMs() + AURUS_CHECK_NETWORK_STATUS;
|
|
uint8_t rssi = QuerySignalQuality(env);
|
|
env->egtsTeledataEdit.egtsSensorsAnArgs.sensorsAnState[SENSORS_AN_RSSI].value = rssi;
|
|
}
|
|
|
|
}
|
|
SystemDelayMs(500);
|
|
}
|
|
}
|
|
|
|
#endif |