From a87785613584f37e32dc16829924449e9ecf9b51 Mon Sep 17 00:00:00 2001 From: cfif Date: Fri, 24 Jan 2025 13:22:33 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9F=D0=B5=D1=80=D0=B5=D0=BD=D0=BE=D1=81=20?= =?UTF-8?q?=D0=BD=D0=B0=20=D0=BD=D0=BE=D0=B2=D1=83=D1=8E=20=D0=BE=D1=80?= =?UTF-8?q?=D0=B3=D0=B0=D0=BD=D0=B8=D0=B7=D0=B0=D1=86=D0=B8=D1=8E=20GONEC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Inc/Tracert.h | 214 ++++++++++++++ Src/Tracert.c | 793 ++++++++++++++++++++++++++++++++++++++++++++++++++ modular.json | 18 ++ 3 files changed, 1025 insertions(+) create mode 100644 Inc/Tracert.h create mode 100644 Src/Tracert.c create mode 100644 modular.json diff --git a/Inc/Tracert.h b/Inc/Tracert.h new file mode 100644 index 0000000..e971276 --- /dev/null +++ b/Inc/Tracert.h @@ -0,0 +1,214 @@ +// +// Created by cfif on 04.10.2022. +// + +#ifndef TRACERT_H +#define TRACERT_H + +#include +#include +#include +#include "ModemMain.h" +#include "External.h" +#include "TaskAdc.h" + +typedef struct { + uint8_t filename[9]; + uint8_t static_null; + uint8_t version; + uint8_t len; + uint8_t nAt[3]; + uint8_t reserve; +} tStructTracertHeader; + +// Точка tracert датчики +#pragma scalar_storage_order big-endian +typedef struct __attribute__ ((packed)) { +// Точка tracert время + // Слово времени + uint32_t year: 6; // Год + uint32_t mouth: 4; // Месяц + uint32_t day: 5; // День + uint32_t hour: 5; // Часы + uint32_t min: 6; // Минуты + uint32_t sec: 6; // Секунды + + // Точка tracert координаты + uint32_t lat_data_static: 2; // 01 - Резерв + uint32_t lat_latLonFlag: 1; // Полушарие N - 0 S - 1 + uint32_t lat_direction: 1; // 0 - Признак широты + uint32_t lat_absFullDeg: 8; // Градусы + uint32_t lat_absFullMin: 6; // Минуты + uint32_t lat_absFrOfMin: 14; // Доли минут после точки + + // Точка tracert координаты + uint32_t lon_data_static: 2; // 01 - Резерв + uint32_t lon_latLonFlag: 1; // 0 - Признак широты + uint32_t lon_direction: 1; // Полушарие N - 0 S - 1 + uint32_t lon_absFullDeg: 8; // Градусы + uint32_t lon_absFullMin: 6; // Минуты + uint32_t lon_absFrOfMin: 14; // Доли минут после точки + + // Слово датчиков + uint32_t id_static2: 4; // 1000 - Резерв + uint32_t EC: 1; // Признак слова курса + uint32_t reserver2: 2; + uint32_t D3: 1; // + uint32_t D2: 1; // + uint32_t D1: 1; // Датчик вскрытия + uint32_t AL: 1; // Тревога + uint32_t IG: 1; // Зажигание + uint32_t sensor_B: 10; // + uint32_t sensor_A: 10; // + +// Точка tracert курс скорость температура + uint32_t id_static1: 4; // 1001 + uint32_t reserved: 1; + uint32_t temperature: 8; + uint32_t curse: 9; // + uint32_t speed: 10; // + + // Доп. Данные + uint8_t addition[12]; + +} tStructTracertPoint; +#pragma scalar_storage_order little-endian + + +// Точка tracert координаты +#pragma scalar_storage_order big-endian +typedef struct __attribute__ ((packed)) { + uint32_t data_static: 2; // 01 - Резерв + uint32_t latLonFlag: 1; // 0 - Признак широты + uint32_t direction: 1; // Полушарие N - 0 S - 1 + uint32_t absFullDeg: 8; // Градусы + uint32_t absFullMin: 6; // Минуты + uint32_t absFrOfMin: 14; // Доли минут после точки +} tStructTracertCoord; +#pragma scalar_storage_order little-endian + +// Точка tracert время +#pragma scalar_storage_order big-endian +typedef struct __attribute__ ((packed)) { + // Слово времени + uint32_t year: 6; // Год + uint32_t mouth: 4; // Месяц + uint32_t day: 5; // День + uint32_t hour: 5; // Часы + uint32_t min: 6; // Минуты + uint32_t sec: 6; // Секунды +} tStructTracertDateTime; +#pragma scalar_storage_order little-endian + +// Точка tracert курс скорость температура +#pragma scalar_storage_order big-endian +typedef struct __attribute__ ((packed)) { + uint32_t id_static: 4; // 1001 + uint32_t reserved: 1; + uint32_t temperature: 8; + uint32_t curse: 9; // + uint32_t speed: 10; // +} tStructTracertSpeedCursePoint; +#pragma scalar_storage_order little-endian + + +// Слово датчиков +#pragma scalar_storage_order big-endian +typedef struct __attribute__ ((packed)) { + uint32_t id_static: 4; // 1000 - Резерв + uint32_t EC: 1; // Признак слова курса + uint32_t reserver2: 2; + uint32_t D3: 1; // + uint32_t D2: 1; // + uint32_t D1: 1; // Датчик вскрытия + uint32_t AL: 1; // Тревога + uint32_t IG: 1; // Зажигание + uint32_t sensor_B: 10; // + uint32_t sensor_A: 10; // +} tStructTracertSensorAB; +#pragma scalar_storage_order little-endian + +/* +typedef struct { + tSerialPortIO *io; + tDeviceStorageIni *store; + + struct { + uint8_t modemRx[512]; + uint8_t modemTx[512]; + } mem; + + tAtCmd tracertAt; + osMutexId_t sensorAccess; + uint8_t sensorA[2]; + uint8_t sensorB[2]; + uint8_t sensorExt1[4]; + uint8_t sensorExt2[4]; + uint8_t sensorExt3[4]; + uint8_t sensorExt4[4]; + + struct { + osThreadId_t id; + uint32_t stack[2048]; + StaticTask_t controlBlock; + osThreadAttr_t attr; + } thread; + +} tTracertSensor; +*/ +typedef struct { + tDeviceStorageIni *store; + tGnss *gnss; + + struct { + osThreadId_t id; + uint32_t stack[2048]; + StaticTask_t controlBlock; + osThreadAttr_t attr; + } thread; + + uint8_t bufTracert[1300]; + uint8_t stepPoint; + uint32_t posInBlock; + tExternal *external; + tFs *fs; + tRtcIO *rtcIO; + + osMutexId_t accessTracert; + + tModemMain *modemMain; + + tTaskAdc *taskAdc; + + bool isSpeedCurse; + bool isDataAddition; + bool isModemCreateAccess; + bool isModemDelAccess; + + tLoggerInterface *logger; + +} tTracertMain; + +void TracertMain_Init( + tTracertMain *env, + tGnss *gnss, + tDeviceStorageIni *store, + tExternal *external, + tFs *fs, + tTaskAdc *taskAdc, + tRtcIO *rtcIo, + tModemMain *modemMain, + osMutexId_t accessTracert +); + + +//void TracertSensor_Init( +// tTracertSensor *env, +// tSerialPortIO *io, +// tDeviceStorageIni *store +//); + +void TracertMain_StartThread(tTracertMain *env); +//void TracertSensor_StartThread(tTracertSensor *env); + +#endif //TRACERT_H diff --git a/Src/Tracert.c b/Src/Tracert.c new file mode 100644 index 0000000..ece2541 --- /dev/null +++ b/Src/Tracert.c @@ -0,0 +1,793 @@ +// +// Created by cfif on 04.10.2022. +// + +#include +#include +#include +#include +#include "SerialPort.h" +#include "string.h" +#include "fs_base_func.h" +#include +#include "ModemReceiveFunc.h" +#include "ModemSendFunc.h" +#include "ModemSend.h" + +#define LOGGER env->logger +#define LOG_SIGN "GONEC" + +/* +uint16_t crc16(uint8_t *data, size_t data_len) { + // uint16_t xor_in = 0x0000; + uint16_t xor_out = 0xFFFF; + uint16_t poly = 0x1021; + uint16_t reg = 0xFFFF; //xor_in; + for (size_t octet_idx = 0; octet_idx < data_len; octet_idx++) { + uint8_t octet = data[octet_idx]; + for (uint8_t bit_idx = 0; bit_idx < 8; bit_idx++) { + uint16_t topbit = reg & 0x8000; + if (octet & (0x80 >> bit_idx)) { + topbit &= 0x8000; + } + reg <<= 1; + reg |= (octet >> (7 - bit_idx)) & 0x1; + if (topbit) { + reg ^= poly; + } + } + reg &= 0xFFFF; + } + + return reg ^ xor_out; +} + +void TracertSensor_Init(tTracertSensor *env, + tSerialPortIO *io, + tDeviceStorageIni *store +) { + env->io = io; + env->store = store; + env->sensorAccess = osMutexNew(NULL); + + AtCmdInit( + &env->tracertAt, io, + env->mem.modemTx, sizeof(env->mem.modemTx), + env->mem.modemRx, sizeof(env->mem.modemRx), + 2000, 2000 + ); + + //Инициализируем поток + InitThreadAtrStatic(&env->thread.attr, "TracertSensor", env->thread.controlBlock, env->thread.stack, + osPriorityNormal); + env->thread.id = 0; +} + +void getSensorAbExt(tTracertSensor *env, uint8_t *sensorA, uint8_t *sensorB, uint8_t *sensorExt1, uint8_t *sensorExt2, + uint8_t *sensorExt3, uint8_t *sensorExt4) { + if (osMutexAcquire(env->sensorAccess, 1000) == osOK) { + + memcpy(sensorA, env->sensorA, 2); + memcpy(sensorB, env->sensorB, 2); + memcpy(sensorExt1, env->sensorExt1, 4); + memcpy(sensorExt2, env->sensorExt2, 4); + memcpy(sensorExt3, env->sensorExt3, 4); + memcpy(sensorExt4, env->sensorExt4, 4); + + osMutexRelease(env->sensorAccess); + } +} + + +static _Noreturn void TracertSensor_Thread(tTracertSensor *env) { + AtCmdPrepare(&env->tracertAt); + AtCmdRxClear(&env->tracertAt); + uint8_t dataAFX[32]; + uint8_t dataAF[32]; + + for (;;) { + + while (AtCmdReceiveNextLine(&env->tracertAt, 1000) == AT_OK) { + + + if (AtCmdRxBeginWithStatic(&env->tracertAt, "AFX")) { + iAsciiStringParseHexBytes(dataAFX, &env->tracertAt.rxBuffer.data[3], env->tracertAt.rxBuffer.len - 3); + + + uint16_t crc16calc = crc16(dataAFX, 16); + uint16_t crc = ((uint16_t *) &dataAFX)[8]; + + if (osMutexAcquire(env->sensorAccess, 1000) == osOK) { + memcpy(env->sensorExt1, &dataAFX[0], 4); + memcpy(env->sensorExt2, &dataAFX[4], 4); + memcpy(env->sensorExt3, &dataAFX[8], 4); + memcpy(env->sensorExt4, &dataAFX[12], 4); + osMutexRelease(env->sensorAccess); + } + + AtCmdRxClear(&env->tracertAt); + } else if (AtCmdRxBeginWithStatic(&env->tracertAt, "AF")) { + iAsciiStringParseHexBytes(dataAF, &env->tracertAt.rxBuffer.data[2], env->tracertAt.rxBuffer.len - 2); + + if (osMutexAcquire(env->sensorAccess, 1000) == osOK) { + env->sensorA[0] = dataAF[1]; + env->sensorA[1] = dataAF[2]; + env->sensorB[0] = dataAF[4]; + env->sensorB[1] = dataAF[8]; + osMutexRelease(env->sensorAccess); + } + AtCmdRxClear(&env->tracertAt); + } + + AtCmdRxClear(&env->tracertAt); + } + } +} +*/ +void TracertMain_Init( + tTracertMain *env, + tGnss *gnss, + tDeviceStorageIni *store, + tExternal *external, + tFs *fs, + tTaskAdc *taskAdc, + tRtcIO *rtcIo, + tModemMain *modemMain, + osMutexId_t accessTracert +) { + env->store = store; + env->gnss = gnss; + env->stepPoint = 0; + env->taskAdc = taskAdc; + env->external = external; + + env->fs = fs; + env->rtcIO = rtcIo; + + env->isModemDelAccess = true; + + env->modemMain = modemMain; + + env->accessTracert = accessTracert; + + env->isSpeedCurse = false; +/* + const uint8_t data[] = {'A', 'F', 'X', + 0xe1, 0x98, 0x76, 0x54, + 0xe2, 0xab, 0xcd, 0xef, + 0xe3, 0x44, 0x55, 0x66, + 0xe4, 0x99, 0x88, 0x77}; + + uint16_t crc16calc = crc16(&data[3], 16); + + + + uint8_t buf[16] = { 0x38, 0x7a, 0x76, 0x0e, + 0x43, 0x76, 0x4e, 0x2d, + 0x65, 0xd5, 0xe0, 0x14, + 0x80, 0x00, 0x00, 0x00 }; + + uint32_t buf[4] = {0x387a760e, + 0x43764e2d, + 0x65d5e014, + 0x80000000}; + + + + uint32_t buf[4] = { 0x3e74e77b, + 0x43be6582, + 0x61e711d0, + 0x80000000 }; + + tStructTracertPoint *structTracertPoint = (tStructTracertPoint *) buf; +*/ + //Инициализируем поток + InitThreadAtrStatic(&env->thread.attr, "Tracert", env->thread.controlBlock, env->thread.stack, osPriorityNormal); + env->thread.id = 0; +} + + +// Создание и запись в файл +bool createFileTracert(tTracertMain *env) { + + FIL file; + FRESULT fr; + + char real_filename[MAX_LEN_PATH_FS]; + + ++env->store->nvm.maxId_OutBox; + if (env->store->nvm.maxId_OutBox > 32767) + env->store->nvm.maxId_OutBox = 1; + + DeviceStorageCounterIni_Dump(env->store); + + // Запись заголовка в файл + char buf[9]; + + char BufFileWrite[512]; + BufFileWrite[0] = '\0'; + + strcat(BufFileWrite, "&from="); + utoa(env->store->nvm.Settings_General.ATnum_v, &BufFileWrite[strlen(BufFileWrite)], 10); + + strcat(BufFileWrite, "&to="); + utoa(env->store->nvm.Settings_Tracert.TrATsrv_v, buf, 10); + strcat(BufFileWrite, buf); + + strcat(BufFileWrite, "&chSv=1"); + + strcat(BufFileWrite, "&mnum="); + utoa(env->store->nvm.maxId_OutBox, buf, 10); + strcat(BufFileWrite, buf); + + strcat(BufFileWrite, "&urgency=0"); + + strcat(BufFileWrite, "&type=1"); + strcat(BufFileWrite, "&sos=0"); + + strcat(BufFileWrite, "&kvs=0"); + strcat(BufFileWrite, "&subj=file&msg="); + + createFileNameForId(real_filename, "", env->store->nvm.maxId_OutBox, "DAT"); + strcat(BufFileWrite, real_filename); + + + createFileNameForId(real_filename, (char *) dir_tracert, env->store->nvm.maxId_OutBox, "OTM"); + + fr = f_open_i(env->fs, &file, (TCHAR *) real_filename, FA_WRITE | FA_CREATE_ALWAYS); + if (fr) return false; + + UINT bytes_written; + fr = f_write_i(env->fs, &file, BufFileWrite, strlen(BufFileWrite), &bytes_written); + + fr = f_close_i(env->fs, &file); + + + createFileNameForId(real_filename, (char *) dir_tracert, env->store->nvm.maxId_OutBox, "DAT"); + + fr = f_open_i(env->fs, &file, (TCHAR *) real_filename, FA_WRITE | FA_CREATE_ALWAYS); + if (fr) return false; + + fr = f_write_i(env->fs, &file, env->bufTracert, env->posInBlock, &bytes_written); + + fr = f_close_i(env->fs, &file); + + return true; +} + + +// Удаление самого старого файла +void getDelOldTracert(tTracertMain *env) { + FRESULT fr; + DIR dj; + FILINFO fno; + FILINFO fnoInf; + FRESULT frInf; + + char strId[MAX_LEN_PATH_FS]; + strId[0] = '\0'; + + uint32_t minNum = 0xFFFFFFFF; + + fr = f_findfirst_i(env->fs, &dj, &fno, dir_tracert, "*.OTM"); + + char path_Old_fileName[MAX_LEN_PATH_FS]; + path_Old_fileName[0] = '\0'; + + while (fr == FR_OK && fno.fname[0]) { + // Полный путь с именем файла до файла исходящего сообщения REP + char path_tracert_fileName[MAX_LEN_PATH_FS]; + path_tracert_fileName[0] = '\0'; + strcat(path_tracert_fileName, dir_tracert); + strcat(path_tracert_fileName, fno.fname); + + uint32_t Num = atoi(&fno.fname[0]); + + // Самый старый файл + frInf = f_stat(path_tracert_fileName, &fnoInf); + if (frInf == FR_OK) { + if (Num < minNum) { + minNum = Num; + path_Old_fileName[0] = '\0'; + strcat(path_Old_fileName, path_tracert_fileName); + } + } + + fr = f_findnext_i(env->fs, &dj, &fno); + } + fr = f_closedir_i(env->fs, &dj); + + fr = f_unlink_i(env->fs, path_Old_fileName); +} + +static uint32_t reverse32(uint32_t x) { + x = (x & 0x00FF00FF) << 8 | (x & 0xFF00FF00) >> 8; + x = (x & 0x0000FFFF) << 16 | (x & 0xFFFF0000) >> 16; + return x; +} + + +static uint32_t toFrOfMin(double d) { + if (d < 1) + d += 1; + + double orig = d; + + uint32_t kf = 1; + uint32_t test = (uint32_t) d; + uint32_t count = 0; + + while (test != d) { + ++count; + d *= 10; + test = (uint32_t) d; + kf *= 10; + + if (count >= 5) break; + } + + uint32_t result = kf * (orig - (uint32_t) orig); + + return result; +} + +uint16_t minShare(double frMin) { + + return (uint16_t) (frMin * 10000); + + /* + + uint16_t LIM = 0b1111111111111; + + if (frMin < 0.1) { + return 0; + } + uint32_t val = 0; + uint32_t mux = 1; + do { + mux *= 10; + val = frMin * mux; + if (val == 0) { + return val; + } + + if ((val > LIM)) { + mux /= 10; + break; + } + + } while (1); + + val = frMin * mux; + + while (val && ((val % 10) == 0)) { + val /= 10; + } + + return val; + */ +} + +void cConvertFrDegTracer(double frDeg, uint8_t latLonFlag, uint8_t *data) { + + uint8_t direction = frDeg > 0 ? 0 : 1; + + int8_t fullDeg = (int8_t) (frDeg); + double frMin = (frDeg - fullDeg) * 60.0; + + int8_t fullMin = (int8_t) frMin; + + //int16_t frOfMin = (int16_t) ((frMin - fullMin) * 8192); + + uint8_t absFullDeg = (uint8_t) abs((int) fullDeg); + uint8_t absFullMin = abs(fullMin); + + if (frMin < 0) + frMin *= -1; + + uint16_t absFrOfMin = minShare(frMin - (uint16_t) frMin); + //uint16_t absFrOfMin = abs(frOfMin); + + + /* + uint32_t result = + (0b01 << 30) | + ((latLonFlag & 0b1) << 29) | + ((direction) << 28) | + ((absFullDeg) << 20) | + ((absFullMin & 0b111111) << 14) | + ((absFrOfMin & 0b11111111111111)) << 0; +*/ + + tStructTracertCoord *structTracertCoord = (tStructTracertCoord *) data; + structTracertCoord->absFrOfMin = absFrOfMin; // 14: Доли минут после точки + structTracertCoord->absFullMin = absFullMin; // 6: Минуты + structTracertCoord->absFullDeg = absFullDeg; // 8: Градусы + structTracertCoord->direction = direction; // Полушарие + structTracertCoord->latLonFlag = latLonFlag; // Признак широты + structTracertCoord->data_static = 1; // 01 - Резерв +} + +//int8_t temp2; + + +static _Noreturn void TracertMain_Thread(tTracertMain *env) { +/* + uint8_t dataPK[] = {0x5d, 0x6a, 0xad, 0xe5, + 0x43, 0x4b, 0x24, 0x29, + 0x62, 0x96, 0xa1, 0xdc, + 0x88, 0x10, 0x00, 0x00, + 0x91, 0xa0, 0x10, 0x00}; + + uint8_t dataPK2[] = {0x5d, 0x6c, 0xb6, 0xa0, + 0x43, 0x4b, 0x23, 0x40, + 0x62, 0x96, 0x9f, 0xb6, + 0x88, 0x11, 0x54, 0x00, + 0x91, 0xa4, 0x28, 0x00}; + + + tStructTracertPoint *test = (tStructTracertPoint *) &dataPK2[0]; +*/ +/* + uint8_t dataPK[] = {0x5d, 0x42, 0xF5, 0x85, + 0x53, 0xbd, 0xc3, 0xe7, + 0x71, 0xe3, 0x80, 0x00, + 0x88, 0x00, 0x00, 0x00, + 0x90, 0x00, 0x00, 0x00}; + + tStructTracertPoint *test = (tStructTracertPoint *) &dataPK[0]; +*/ + uint32_t maxBuf = env->store->nvm.Settings_Tracert.MaxBuf_v; + env->isModemCreateAccess = true; + + for (;;) { + + // Ждать ГНСС + if (env->store->nvm.Settings_Tracert.TransferCoordSettings_v == 0) { + if (env->modemMain->location.isOneValidGnss) { + SystemDelayMs(100); + continue; + } + } + + // Ждать только времени с ГНСС или ПК +// if ((env->modemMain->location.isOneDateTime) || (env->modemMain->location.isOneValidGnss)) { + if (env->modemMain->location.isOneDateTime) { + SystemDelayMs(100); + continue; + } + + if (env->store->nvm.Settings_Tracert.PeSvCoor_v > 0) { + if (env->store->nvm.Settings_Tracert.mTracer_v > 0) { + env->isModemDelAccess = true; + } + } + + // Трассировка не работает (удаление файлов из отправки) + if ((env->store->nvm.Settings_Tracert.PeSvCoor_v == 0) || + (env->store->nvm.Settings_Tracert.mTracer_v == 0)) { + if (env->isModemDelAccess) { + // Удаление всех файлов трассировки + // delDirFileFs(env->fs, (char *) dir_tracert); + + env->isModemCreateAccess = true; + + env->isModemDelAccess = false; + env->modemMain->stateRequest.stateReqDelExtT = StateReqExtForDel; + } + env->stepPoint = 0; + SystemDelayMs(100); + continue; + } + + // Включение трассировки, после выключения + if (env->isModemCreateAccess) { + delRepout(env->modemMain, TYPE_FILE_TRACERT, true, false); + env->isModemCreateAccess = false; + env->modemMain->stateRequest.stateReqCreateExtT = StateReqExtForCreate; +// SystemDelayMs(100); + } + + + + // начало --------------------------- Заголовок ----------------------------------------------------------------------- + if (env->stepPoint == 0) { + + env->isSpeedCurse = false; + // Передача курса и скорости + if (env->store->nvm.Settings_Tracert.trSendSpeed_v) { + env->isSpeedCurse = true; + } + + // Передача доп. данных + env->isDataAddition = false; + if (env->store->nvm.Settings_Tracert.TransmissionModeData == 1) { + env->isDataAddition = true; + } + + uint8_t headerTracert[16] = {0x74, 0x72, 0x61, 0x63, 0x65, 0x2e, 0x74, 0x6e, 0x64, + 0x00, + 0x01, + 0x10, + 0x00, 0x00, 0x00, + 0x00}; + tStructTracertHeader *structTracertHeader = (tStructTracertHeader *) headerTracert; + structTracertHeader->len = 16; + + if (env->isSpeedCurse) { + structTracertHeader->len = 20; + } + + if (env->isDataAddition) { + structTracertHeader->len = 32; + } + + structTracertHeader->nAt[0] = env->store->nvm.Settings_General.ATnum_v; + structTracertHeader->nAt[1] = env->store->nvm.Settings_General.ATnum_v >> 8; + structTracertHeader->nAt[2] = env->store->nvm.Settings_General.ATnum_v >> 16; + + env->posInBlock = sizeof(tStructTracertHeader); + memcpy(env->bufTracert, headerTracert, sizeof(tStructTracertHeader)); + } + // конец --------------------------- Заголовок ----------------------------------------------------------------------- + + + // начало -------------------------- Дата/Время----------------------------------------------------------------------- + struct tm time; + //env->rtcIO->getTM(&env->rtcIO, &time); + + time_t timestamp; + env->rtcIO->get(&env->rtcIO, ×tamp); + localtime_r(×tamp, &time); + + /* + uint32_t dateTime2 = + (((time.tm_year - 100) & 0b111111) << 26) | + ((time.tm_mon & 0b1111) << 22) | + ((time.tm_mday & 0b11111) << 17) | + ((time.tm_hour & 0b11111) << 12) | + ((time.tm_min & 0b111111) << 6) | + ((time.tm_sec & 0b111111) << 0); + */ + + uint8_t dateTime[4] = {0, 0, 0, 0}; + + tStructTracertDateTime *structTracertDateTime = (tStructTracertDateTime *) &dateTime[0]; + structTracertDateTime->sec = time.tm_sec; // Секунды + structTracertDateTime->min = time.tm_min; // Минуты + structTracertDateTime->hour = time.tm_hour; // Часы + structTracertDateTime->day = time.tm_mday; // День + structTracertDateTime->mouth = time.tm_mon + 1; // Месяц + structTracertDateTime->year = time.tm_year - 100; // Год + + memcpy(&env->bufTracert[env->posInBlock], &dateTime[0], 4); + env->posInBlock += 4; + + tTracertNavData location; + // конец -------------------------- Дата/Время----------------------------------------------------------------------- + + + // начало ------------------------ Широта/Долгота-------------------------------------------------------------------- + uint8_t latitude[4] = {0, 0, 0, 0}; + uint8_t longitude[4] = {0, 0, 0, 0}; + + // Координаты с ГНСС не были получены никогда + if (env->modemMain->location.isOneValidGnss) { + cConvertFrDegTracer(env->modemMain->location.latitude, 0, &latitude[0]); + cConvertFrDegTracer(env->modemMain->location.longitude, 1, &longitude[0]); + location.speed = 0; + location.curse = 0; + +// char bufText[128]; +// bufText[0] = '\0'; +// strcat(bufText, "Координаты (по умолчанию) "); +// char buf[12]; +// utoa((uint32_t) env->modemMain->location.latitude, buf, 10); +// strcat(bufText, buf); +// strcat(bufText, ", "); +// utoa((uint32_t) env->modemMain->location.longitude, buf, 10); +// strcat(bufText, buf); +// LoggerInfo(LOGGER, LOG_SIGN, bufText, strlen(bufText)); + + } else { + Gnss_GetNavDataTracert(env->gnss, &location); + cConvertFrDegTracer(location.gnss_latitude, 0, &latitude[0]); + cConvertFrDegTracer(location.gnss_longitude, 1, &longitude[0]); + +// char bufText[128]; +// bufText[0] = '\0'; +// strcat(bufText, "Координаты (с ГНСС) "); +// char buf[12]; +// utoa((uint32_t) location.gnss_latitude, buf, 10); +// strcat(bufText, buf); +// strcat(bufText, ", "); +// utoa((uint32_t) location.gnss_longitude, buf, 10); +// strcat(bufText, buf); +// LoggerInfo(LOGGER, LOG_SIGN, bufText, strlen(bufText)); + } + + memcpy(&env->bufTracert[env->posInBlock], &latitude[0], 4); + env->posInBlock += 4; + memcpy(&env->bufTracert[env->posInBlock], &longitude[0], 4); + env->posInBlock += 4; + // конец ------------------------ Широта/Долгота-------------------------------------------------------------------- + + uint16_t sensorA; + uint16_t sensorB; + uint8_t sensorExt[16]; + + getSensorAbExt(env->external, &sensorA, &sensorB, sensorExt); + + // начало ---------------------------Датчики------------------------------------------------------------------------ +/* + uint32_t IG = 0; // Зажигание + uint32_t AL = 0; // Тревога + uint32_t D1 = 0; // Датчик вскрытия + uint32_t D2 = 0; // + uint32_t D3 = 0; // + uint32_t EC = 0; // Признак слова курса + + if (env->isSpeedCurse) { + EC = 1; // Признак слова курса + } + + uint32_t SensorABPoint2 = + (8 << 28) | + ((EC & 0b1) << 27) | + ((D3 & 0b1) << 24) | + ((D2 & 0b1) << 23) | + ((D1 & 0b1) << 22) | + ((AL & 0b1) << 21) | + ((IG & 0b1) << 20) | + ((sensorB & 0b1111111111) << 10) | + ((sensorA & 0b1111111111) << 0); +*/ + uint8_t SensorABPoint[4] = {0, 0, 0, 0}; + tStructTracertSensorAB *structTracertSensorAB = (tStructTracertSensorAB *) &SensorABPoint[0]; + structTracertSensorAB->sensor_A = sensorA; // + structTracertSensorAB->sensor_B = sensorB; // + structTracertSensorAB->IG = 0; // Зажигание + structTracertSensorAB->AL = 0; // Тревога + structTracertSensorAB->D1 = 0; // Датчик вскрытия + structTracertSensorAB->D2 = 0; // + structTracertSensorAB->D3 = 0; // + structTracertSensorAB->reserver2 = 0; + + structTracertSensorAB->EC = 0; // Признак слова курса + if (env->isSpeedCurse) { + structTracertSensorAB->EC = 1; // Признак слова курса + } + + structTracertSensorAB->id_static = 8; // 1000 + + // Передача напряжения + if (env->store->nvm.Settings_Tracert.SensorAD0volt_v) { + uint32_t vcc = getVcc(env->taskAdc) / 1000; + structTracertSensorAB->sensor_A = vcc; + } + + memcpy(&env->bufTracert[env->posInBlock], &SensorABPoint[0], 4); + env->posInBlock += 4; + // конец ---------------------------Датчики---------------------------------------------------------------------- + + // начало --------------------------Курс и скорость------------------------------------------------------------- + if (env->isSpeedCurse) { +/* + uint32_t SpeedCursePoint2 = + (9 << 28) | + ((location.temperature & 0b11111111) << 19) | + ((location.curse & 0b111111111) << 10) | + ((location.speed & 0b1111111111) << 0); +*/ + uint8_t SpeedCursePoint[4] = {0, 0, 0, 0}; + tStructTracertSpeedCursePoint *structTracertSpeedCursePoint = (tStructTracertSpeedCursePoint *) &SpeedCursePoint[0]; + structTracertSpeedCursePoint->speed = location.speed; + structTracertSpeedCursePoint->curse = location.curse; + + uint8_t temp; + if (env->modemMain->temp < 0) { + temp = (env->modemMain->temp * -1); + temp |= 0x80; + } else { + temp = env->modemMain->temp; + } + + structTracertSpeedCursePoint->temperature = temp; + structTracertSpeedCursePoint->reserved = 0; + structTracertSpeedCursePoint->id_static = 9; // 1001 + + memcpy(&env->bufTracert[env->posInBlock], &SpeedCursePoint[0], 4); + env->posInBlock += 4; + } + // конец --------------------------Курс и скорость------------------------------------------------------------- + + // начало ---------------------------Доп данные------------------------------------------------------------------ + if (env->isDataAddition) { + if (env->isSpeedCurse) { + memcpy(&env->bufTracert[env->posInBlock], &sensorExt[4], 12); + env->posInBlock += 12; + } else { + memcpy(&env->bufTracert[env->posInBlock], &sensorExt[0], 16); + env->posInBlock += 16; + } + } + // конец ---------------------------Доп данные------------------------------------------------------------------- + + + volatile tStructTracertPoint *structTracertPoint = (tStructTracertPoint *) &env->bufTracert[16]; + + ++env->stepPoint; + if ((env->stepPoint >= env->store->nvm.Settings_Tracert.minPtoSe_v) || ((env->stepPoint >= 38))) { + env->stepPoint = 0; + + + env->rtcIO->get(&env->rtcIO, ×tamp); + while (env->modemMain->isEnableTracerTimeStamp >= (uint32_t) timestamp) { + env->rtcIO->get(&env->rtcIO, ×tamp); + SystemDelayMs(1000); + } + + if (osMutexAcquire(env->accessTracert, 2000) == osOK) { + createFileTracert(env); + + // Количество файлов в tracert + uint32_t count = getCountFiles(env->modemMain, (char *) dir_tracert); + + while (count > env->store->nvm.Settings_Tracert.MaxFiles_v) { + + // Удаление самого старого файла tracert + delFilesOld(env->modemMain, (char *) dir_tracert); + + // Количество файлов в tracert + count = getCountFiles(env->modemMain, (char *) dir_tracert); + + } + + env->rtcIO->get(&env->rtcIO, &env->modemMain->eventWebState.EVENT_TRACERT); + + // Чтобы не запрашивать лишний раз модем. Если в трассировке уже есть максимум файлов для отправки. + if (getCountTracertInRepoutCute(env->fs, env->store->nvm.Settings_Tracert.MaxBuf_v) < + env->store->nvm.Settings_Tracert.MaxBuf_v) + env->modemMain->stateRequest.stateReqCreateExtT = StateReqExtForCreate; + + + osMutexRelease(env->accessTracert); + } + + } + + for (uint32_t i = 0; i < env->store->nvm.Settings_Tracert.PeSvCoor_v; ++i) { + if ((env->store->nvm.Settings_Tracert.PeSvCoor_v == 0) || + (env->store->nvm.Settings_Tracert.mTracer_v == 0)) { + break; + } + + if (maxBuf != env->store->nvm.Settings_Tracert.MaxBuf_v) { + maxBuf = env->store->nvm.Settings_Tracert.MaxBuf_v; + delRepout(env->modemMain, TYPE_FILE_TRACERT, true, false); + env->modemMain->stateRequest.stateReqCreateExtT = StateReqExtForCreate; + } + + SystemDelayMs(1000); + } + } + +} + +void TracertMain_StartThread(tTracertMain *env) { + if (!env->thread.id) { + env->thread.id = osThreadNew((osThreadFunc_t) (TracertMain_Thread), (void *) (env), &env->thread.attr); + } else { + osThreadResume(env->thread.id); + } +} + +/* +void TracertSensor_StartThread(tTracertSensor *env) { + if (!env->thread.id) { + env->thread.id = osThreadNew((osThreadFunc_t) (TracertSensor_Thread), (void *) (env), &env->thread.attr); + } else { + osThreadResume(env->thread.id); + } +} +*/ \ No newline at end of file diff --git a/modular.json b/modular.json new file mode 100644 index 0000000..2774ab2 --- /dev/null +++ b/modular.json @@ -0,0 +1,18 @@ +{ + "dep": [ + { + "type": "git", + "provider": "GONEC", + "repo": "SystemDelayInterface" + } + ], + + "cmake": { + "inc_dirs": [ + "Inc" + ], + "srcs": [ + "Src/**.c" + ] + } +} \ No newline at end of file