1504 lines
51 KiB
C
1504 lines
51 KiB
C
//
|
||
// Created by cfif on 21.04.23.
|
||
//
|
||
#include "ModemMain.h"
|
||
#include "ModemReceiveFunc.h"
|
||
#include "ModemSendFunc.h"
|
||
#include "ModemGonecFunc.h"
|
||
#include "ModemBufCreateHeader.h"
|
||
|
||
#define LOGGER env->logger
|
||
#define LOG_SIGN "GONEC"
|
||
|
||
|
||
//начало -------------------------Запрос передающих слотов на модем--------------------------------------------------------
|
||
//начало -------------------------Запрос передающих слотов на модем--------------------------------------------------------
|
||
//начало -------------------------Запрос передающих слотов на модем--------------------------------------------------------
|
||
void RequestModemSendSlots(tModemMain *env) {
|
||
bool result;
|
||
|
||
// Запрос слотов передачи
|
||
result = ModemGetSlot(env, env->modemStatus.id, (uint8_t *) env->modemStatus.status, 16);
|
||
|
||
if (result) {
|
||
|
||
for (int id = 0; id < 16; ++id) {
|
||
if (env->modemStatus.status[id] != env->modemStatusOld[id]) {
|
||
//env->modemSlotSendStatusReload = true;
|
||
}
|
||
env->modemStatusOld[id] = env->modemStatus.status[id];
|
||
}
|
||
}
|
||
|
||
}
|
||
//конец --------------------------Запрос передающих слотов на модем--------------------------------------------------------
|
||
//конец --------------------------Запрос передающих слотов на модем--------------------------------------------------------
|
||
//конец --------------------------Запрос передающих слотов на модем--------------------------------------------------------
|
||
|
||
|
||
bool getIsSlotsFree(tModemMain *env) {
|
||
bool isSlotFree = false;
|
||
for (int i = 0; i < 16; ++i) {
|
||
if (env->modemStatus.status[i] == SLOT_FREE) {
|
||
isSlotFree = true;
|
||
break;
|
||
}
|
||
}
|
||
return isSlotFree;
|
||
}
|
||
|
||
bool getIsSlotsSos(tModemMain *env) {
|
||
bool isSlotSos = false;
|
||
for (int i = 0; i < 16; ++i) {
|
||
if (env->modemStatus.sos[i] == 1) {
|
||
isSlotSos = true;
|
||
break;
|
||
}
|
||
}
|
||
return isSlotSos;
|
||
}
|
||
|
||
uint32_t getSlotsMemSize(tModemMain *env) {
|
||
uint32_t size = 0;
|
||
for (int i = 0; i < 16; ++i) {
|
||
if (env->modemStatus.status[i] != SLOT_FREE) {
|
||
size += env->modemStatus.sendLen[i];
|
||
}
|
||
}
|
||
return size;
|
||
}
|
||
|
||
|
||
// Поиск самого срочного сообщения
|
||
uint32_t getMaxUrgencyRepout(tModemMain *env) {
|
||
tFileSendInfo fileSendInfo;
|
||
bool result = true;
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
char path_dir_rep_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_mask_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_info_fileName[MAX_LEN_PATH_FS];
|
||
|
||
uint32_t maxUrgency = 0;
|
||
uint32_t maxMnum = 0xFFFFFFFF;
|
||
|
||
fr = f_findfirst_i(env->fs, &dj, &fno, dir_rep_out, "*.INF");
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
uint32_t idFile = atoi(fno.fname);
|
||
|
||
createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
|
||
path_dir_mask_fileName,
|
||
path_dir_info_fileName,
|
||
(char *) dir_rep_out, idFile);
|
||
|
||
bool resultFileInfo = readSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
|
||
|
||
if (resultFileInfo == false) {
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
|
||
char strId[MAX_LEN_PATH_FS];
|
||
strId[0] = '\0';
|
||
|
||
bool isDelModem = false;
|
||
|
||
|
||
// Запись в файл маски признака отправленного пакета
|
||
for (int i = 0; i < 16; ++i) {
|
||
|
||
// Пакет отправлен
|
||
if ((env->modemStatus.status[i] == SLOT_READY_SENDING) &&
|
||
(env->modemStatus.idMessage[i] == fileSendInfo.mnum)) {
|
||
|
||
uint32_t sizeHead = sizeof(tStructTransportPacket);
|
||
if (fileSendInfo.typeFile == TYPE_FILE_KVITIN) {
|
||
sizeHead = sizeof(tStructTransportKvitPacket);
|
||
}
|
||
|
||
result = editMaskPacketTransport(env->fs, env->modemStatus.sendFrom[i],
|
||
env->modemStatus.sendLen[i] - sizeHead,
|
||
path_dir_mask_fileName,
|
||
BUF_RECEIVE);
|
||
|
||
if (result == false) {
|
||
break;
|
||
}
|
||
|
||
isDelModem = true;
|
||
|
||
char buffer[12];
|
||
utoa(i + 1, buffer, 10);
|
||
strcat(strId, buffer);
|
||
strcat(strId, ",");
|
||
|
||
env->modemStatus.status[i] = SLOT_INIT;
|
||
}
|
||
}
|
||
|
||
// Отправка на модем команды удаления пакетов
|
||
if (isDelModem) {
|
||
|
||
// Контроль состояния процентов индикации отправки
|
||
bool isFind;
|
||
result = isFindMaskPacketTransport(env->fs, &isFind, path_dir_mask_fileName, &fileSendInfo);
|
||
|
||
if (result == false) {
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
fileSendInfo.crc32_MSK = CrcFileFs(env->fs, path_dir_mask_fileName);
|
||
writeSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
|
||
|
||
if (osMutexAcquire(env->accessHTTP, TIME_MUTEX_HTTP_ACCESS) == osOK) {
|
||
createBufStateFileSend(env->fs);
|
||
osMutexRelease(env->accessHTTP);
|
||
}
|
||
|
||
strId[strlen(strId) - 1] = '\0';
|
||
result = SlotClearNoStartTask(env, strId);
|
||
|
||
// Запрос слотов передачи
|
||
RequestModemSendSlots(env);
|
||
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
// Пропуск просканированых файлов
|
||
bool isContinue = false;
|
||
|
||
for (uint32_t i = 0; i < env->mnumBufScanCount; ++i) {
|
||
if (env->mnumBufScan[i] == idFile) {
|
||
isContinue = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (isContinue) {
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
if ((fileSendInfo.mnum < maxMnum) && (fileSendInfo.urgency >= maxUrgency)) {
|
||
|
||
// Пришел пакет SOS
|
||
if ((env->store->nvm.flagSos == 1) && (fileSendInfo.sos == 0)) {
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
// Трассировка выключена
|
||
if ((env->store->nvm.Settings_Tracert.PeSvCoor_v == 0) ||
|
||
(env->store->nvm.Settings_Tracert.mTracer_v == 0)) {
|
||
if (fileSendInfo.typeFile == TYPE_FILE_TRACERT) {
|
||
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
maxUrgency = fileSendInfo.urgency;
|
||
maxMnum = fileSendInfo.mnum;
|
||
|
||
}
|
||
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(env->fs, &dj);
|
||
|
||
|
||
if (maxMnum != 0xFFFFFFFF) {
|
||
|
||
bool isSlotFree = getIsSlotsFree(env);
|
||
|
||
// Если есть высокоприоритетные сообщения
|
||
if (isSlotFree == false) {
|
||
for (int i = 0; i < 16; ++i) {
|
||
if ((env->modemStatus.urgency[i] < maxUrgency) && (env->modemStatus.idMessage[i] != 0)) {
|
||
return maxMnum;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Все слоты заняты
|
||
if (isSlotFree == false) {
|
||
return 0;
|
||
}
|
||
|
||
}
|
||
/*
|
||
if (maxMnum != 0) {
|
||
|
||
bool isSlotFree = getIsSlotsFree(env);
|
||
|
||
// Если есть высокоприоритетные сообщения
|
||
if (isSlotFree == false) {
|
||
for (int i = 0; i < 16; ++i) {
|
||
if ((env->modemStatus.urgency[i] < maxUrgency) && (env->modemStatus.idMessage[i] != 0)) {
|
||
return maxMnum;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Все слоты заняты. Нельзя вовращать 0
|
||
if (isSlotFree == false) {
|
||
return 0;
|
||
}
|
||
|
||
}
|
||
*/
|
||
bool isSlotFree = getIsSlotsFree(env);
|
||
// Все слоты заняты
|
||
if (isSlotFree == false) {
|
||
return 0;
|
||
}
|
||
|
||
if (maxMnum == 0xFFFFFFFF)
|
||
return 0;
|
||
|
||
return maxMnum;
|
||
}
|
||
|
||
|
||
bool ToSentFiles(tModemMain *env, tFileSendInfo *fileSendInfo,
|
||
char *path_dir_rep_fileName,
|
||
char *path_dir_mask_fileName,
|
||
char *path_dir_info_fileName) {
|
||
|
||
|
||
// Квитируемое сообщение - еще не отквитировано полностью
|
||
if ((fileSendInfo->kvs == 1) && (fileSendInfo->isSendAll == 0)) {
|
||
return true;
|
||
}
|
||
|
||
// Поиск пакетов в модеме на случай, если они загружены в модем на передачу
|
||
char strId[MAX_LEN_PATH_FS];
|
||
strId[0] = '\0';
|
||
|
||
bool isDelModem = false;
|
||
|
||
for (int i = 0; i < 16; ++i) {
|
||
if (env->modemStatus.idMessage[i] == fileSendInfo->mnum) {
|
||
|
||
isDelModem = true;
|
||
|
||
char buffer[12];
|
||
utoa(i + 1, buffer, 10);
|
||
strcat(strId, buffer);
|
||
strcat(strId, ",");
|
||
|
||
env->modemStatus.status[i] = SLOT_INIT;
|
||
}
|
||
}
|
||
|
||
// Отправка на модем команды удаления пакетов
|
||
if (isDelModem) {
|
||
strId[strlen(strId) - 1] = '\0';
|
||
bool result = SlotClearNoStartTask(env, strId);
|
||
}
|
||
|
||
|
||
if (env->store->nvm.Settings_General.SaveToSentBox_v) {
|
||
bool result = renameFromOutBoxToSentBox(env->fs, env->rtcIo, fileSendInfo);
|
||
if (result == false) {
|
||
env->modemSlotSendStatusReload = true;
|
||
return false;
|
||
}
|
||
|
||
} else {
|
||
// Путь к файлу в OUTBOX
|
||
char path_out_fileName[MAX_LEN_PATH_FS];
|
||
path_out_fileName[0] = '\0';
|
||
|
||
if (fileSendInfo->typeFile == TYPE_FILE_TRACERT) {
|
||
createFileNameForId(path_out_fileName, (char *) dir_tracert, fileSendInfo->mnum, "OTM");
|
||
} else {
|
||
createFileNameForId(path_out_fileName, (char *) dir_outbox, fileSendInfo->mnum, "OTM");
|
||
}
|
||
|
||
f_unlink_i(env->fs, path_out_fileName);
|
||
|
||
}
|
||
|
||
FRESULT fr;
|
||
fr = f_unlink_i(env->fs, path_dir_rep_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_mask_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_info_fileName);
|
||
|
||
env->rtcIo->get(&env->rtcIo, &env->eventWebState.EVENT_OUTBOX);
|
||
env->rtcIo->get(&env->rtcIo, &env->eventWebState.EVENT_TRACERT);
|
||
env->rtcIo->get(&env->rtcIo, &env->eventWebState.EVENT_SENTBOX);
|
||
|
||
env->stateRequest.stateReqCreateExtW = StateReqExtForCreate;
|
||
env->stateRequest.stateReqCreateExtT = StateReqExtForCreate;
|
||
|
||
return true;
|
||
}
|
||
|
||
// Обработчик создания исходящих пакетов в модем
|
||
bool HandlerModemOutPaket(tModemMain *env) {
|
||
tFileSendInfo fileSendInfo;
|
||
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
char path_dir_rep_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_mask_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_info_fileName[MAX_LEN_PATH_FS];
|
||
|
||
bool resultKvit;
|
||
|
||
// Модем освободил слот
|
||
for (int id = 0; id < 16; ++id) {
|
||
if (env->modemStatus.status[id] == SLOT_FREE) {
|
||
env->modemStatus.idMessage[id] = 0;
|
||
}
|
||
}
|
||
|
||
bool result = true;
|
||
bool isStopSend = false;
|
||
|
||
// fr = f_findfirst_i(env->fs, &dj, &fno, dir_rep_out, "*.INF");
|
||
// while (fr == FR_OK && fno.fname[0]) {
|
||
env->mnumBufScanCount = 0;
|
||
|
||
uint32_t mnum = getMaxUrgencyRepout(env);
|
||
while (mnum) {
|
||
|
||
// bool isSlotFree = getIsSlotsFree(env);
|
||
// if (isSlotFree == false) {
|
||
// break;
|
||
// }
|
||
|
||
// Запись уже просканированных файлов
|
||
env->mnumBufScan[env->mnumBufScanCount] = mnum;
|
||
++env->mnumBufScanCount;
|
||
if (env->mnumBufScanCount > sizeof(env->mnumBufScan))
|
||
return true;
|
||
|
||
uint32_t idFile = mnum;
|
||
|
||
createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
|
||
path_dir_mask_fileName,
|
||
path_dir_info_fileName,
|
||
(char *) dir_rep_out, idFile);
|
||
|
||
bool resultFileInfo = readSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
|
||
if (resultFileInfo == false) {
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
// Поиск не отправленных блоков в файле маски
|
||
bool isFind;
|
||
//result = isFindMaskPacketTransport(env->fs, &isFind, path_dir_mask_fileName, &fileSendInfo);
|
||
result = isFindMaskPacketTransportIsNotProc(env->fs, &isFind, path_dir_mask_fileName);
|
||
if (result == false) {
|
||
break;
|
||
}
|
||
|
||
// Контроль состояния процентов индикации отправки
|
||
// if (fileSendInfo.typeFile == TYPE_FILE_MESSAGE) {
|
||
// result = createBufStateFileSend(env->fs, env->fileSendInfoForJson, 32);
|
||
// if (result == false) {
|
||
// break;
|
||
// }
|
||
// }
|
||
|
||
// resultFileInfo = writeSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
|
||
// if (resultFileInfo == false) {
|
||
// env->modemSlotSendStatusReload = true;
|
||
// return false;
|
||
// }
|
||
|
||
// Если найдены не отправленные блоки
|
||
if (isFind) {
|
||
//начало------------------------------------Отправка пакетов на модем---------------------------------------------------
|
||
//начало------------------------------------Отправка пакетов на модем---------------------------------------------------
|
||
//начало------------------------------------Отправка пакетов на модем---------------------------------------------------
|
||
bool isFrom = true;
|
||
bool isSlotFree = true;
|
||
uint32_t from = 0;
|
||
uint32_t lenTransPaket = 0;
|
||
|
||
while ((isFrom) && (isSlotFree)) {
|
||
|
||
// Если модем в передаче не передавать данные в модем
|
||
if (env->pwramp) {
|
||
isSlotFree = false;
|
||
break;
|
||
}
|
||
|
||
// Проверка ограничения канала
|
||
uint32_t memSize = getSlotsMemSize(env);
|
||
if (memSize / 1300 > env->store->nvm.Settings_Basic_Access.MaxSzDataOnKB_v) {
|
||
isSlotFree = false;
|
||
break;
|
||
}
|
||
|
||
|
||
tStructTransportPacket *trans;
|
||
tStructRepresentationPacket *rep;
|
||
|
||
if (fileSendInfo.typeFile == TYPE_FILE_KVITIN) {
|
||
|
||
if (lenTransPaket > 0)
|
||
lenTransPaket -= sizeof(tStructTransportKvitPacket);
|
||
|
||
result = createPacketKvitin(env->fs,
|
||
from + lenTransPaket,
|
||
env->bufSendPacket,
|
||
&isFrom,
|
||
&from,
|
||
&lenTransPaket,
|
||
&fileSendInfo,
|
||
env->rtcIo,
|
||
path_dir_rep_fileName,
|
||
path_dir_mask_fileName);
|
||
|
||
} else {
|
||
|
||
if (lenTransPaket > 0)
|
||
lenTransPaket -= sizeof(tStructTransportPacket);
|
||
|
||
result = createPacketTransport(env->fs,
|
||
from + lenTransPaket,
|
||
env->bufSendPacket,
|
||
&isFrom,
|
||
&from,
|
||
&lenTransPaket,
|
||
&fileSendInfo,
|
||
env->rtcIo,
|
||
path_dir_rep_fileName,
|
||
path_dir_mask_fileName);
|
||
|
||
trans = (tStructTransportPacket *) &env->bufSendPacket[0];
|
||
rep = (tStructRepresentationPacket *) &env->bufSendPacket[sizeof(tStructTransportPacket)];
|
||
|
||
}
|
||
|
||
if (result == false) {
|
||
env->modemSlotSendStatusReload = true;
|
||
return false;
|
||
}
|
||
|
||
// Проверка на уже переданный модему блок
|
||
bool isNoSend = true;
|
||
for (int i = 0; i < 16; ++i) {
|
||
if ((env->modemStatus.id[i] != 0) &&
|
||
(env->modemStatus.sendFrom[i] == from) &&
|
||
(env->modemStatus.sendLen[i] == lenTransPaket) &&
|
||
(env->modemStatus.idMessage[i] == fileSendInfo.mnum)) {
|
||
isNoSend = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Если блок уже загружен в модем, то перейти к проверке следующего блока
|
||
if (isNoSend == false) {
|
||
continue;
|
||
//break;
|
||
}
|
||
|
||
|
||
// Найден не отправленный блок
|
||
if ((isFrom) && (isNoSend)) {
|
||
|
||
// Поиск более приоритетных сообщений !!!!!!!!!!!!!!
|
||
if (getIsSlotsFree(env) == false) {
|
||
for (int i = 0; i < 16; ++i) {
|
||
if ((env->modemStatus.urgency[i] < fileSendInfo.urgency) &&
|
||
(env->modemStatus.idMessage[i] != 0)) {
|
||
|
||
char buffer[12];
|
||
utoa(i + 1, buffer, 10);
|
||
//result = SlotClear(env, buffer);
|
||
|
||
isStopSend = true;
|
||
result = ModemStopSend(env);
|
||
result = SlotClearNoStopTask(env, buffer);
|
||
|
||
// Запрос слотов передачи
|
||
result = ModemGetSlot(env, env->modemStatus.id,
|
||
(uint8_t *) env->modemStatus.status, 16);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
bool isNotSlotFree = true;
|
||
|
||
for (int i = 0; i < 16; ++i) {
|
||
if (env->modemStatus.status[i] == SLOT_FREE) {
|
||
isNotSlotFree = false;
|
||
|
||
if (isStopSend == false) {
|
||
isStopSend = true;
|
||
if (env->modemWorkingState != MODEM_WORKING_MSG) {
|
||
// Останов регистрации
|
||
StopRegTask(env);
|
||
// Останов альманаха
|
||
AlmaStop(env);
|
||
}
|
||
result = ModemStopSend(env);
|
||
}
|
||
|
||
// ModemStopSend(env);
|
||
|
||
uint32_t urgency = fileSendInfo.urgency;
|
||
if (fileSendInfo.urgency > 3) {
|
||
urgency = 3;
|
||
}
|
||
|
||
#ifdef DEBUG_EXT_MODEM
|
||
char bufText[128];
|
||
bufText[0] = '\0';
|
||
|
||
// Квитанция
|
||
if (fileSendInfo.typeFile == TYPE_FILE_KVITIN) {
|
||
|
||
tStructTransportKvitPacket *transKvit = (tStructTransportKvitPacket *) &env->bufSendPacket[0];
|
||
|
||
strcat(bufText, "Загрузка пакета квитанции на сообщение номер ");
|
||
|
||
char buf[12];
|
||
utoa(transKvit->numberMessage, buf, 10);
|
||
strcat(bufText, buf);
|
||
|
||
strcat(bufText, ", получатель АТ-");
|
||
utoa(atoi(fileSendInfo.to), buf, 10);
|
||
strcat(bufText, buf);
|
||
|
||
LoggerInfo(LOGGER, LOG_SIGN, bufText, strlen(bufText));
|
||
} else {
|
||
strcat(bufText, "Загрузка пакета номер ");
|
||
|
||
char buf[12];
|
||
utoa(trans->numberMessage, buf, 10);
|
||
strcat(bufText, buf);
|
||
strcat(bufText, ", смещение ");
|
||
utoa(trans->offsetPacket, buf, 10);
|
||
strcat(bufText, buf);
|
||
strcat(bufText, ", получатель АТ-");
|
||
utoa(atoi(fileSendInfo.to), buf, 10);
|
||
strcat(bufText, buf);
|
||
|
||
|
||
LoggerInfo(LOGGER, LOG_SIGN, bufText, strlen(bufText));
|
||
}
|
||
#endif
|
||
|
||
uint32_t adrAT;
|
||
if (isTo(fileSendInfo.to, '@')) {
|
||
adrAT = 7;
|
||
} else {
|
||
adrAT = atoi(fileSendInfo.to);
|
||
}
|
||
|
||
// Запись данных в пакет
|
||
result = SlotWrite(env, i, env->store->nvm.Settings_Basic_Access.NumRegStation_v,
|
||
adrAT,
|
||
urgency,
|
||
fileSendInfo.kvs, lenTransPaket);
|
||
|
||
//bool resultStartSend = ModemStartSend(env);
|
||
//if (resultStartSend)
|
||
// env->modemWorkingState = MODEM_WORKING_MSG;
|
||
//SystemDelayMs(1000);
|
||
|
||
|
||
//result = true;
|
||
if (result) {
|
||
env->modemStatus.idMessage[i] = fileSendInfo.mnum;
|
||
env->modemStatus.sendFrom[i] = from;
|
||
env->modemStatus.sendLen[i] = lenTransPaket;
|
||
env->modemStatus.urgency[i] = fileSendInfo.urgency;
|
||
env->modemStatus.sos[i] = fileSendInfo.sos;
|
||
env->modemStatus.type[i] = fileSendInfo.typeFile;
|
||
env->modemStatus.status[i] = SLOT_INIT;
|
||
break;
|
||
} else {
|
||
env->modemSlotSendStatusReload = true;
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Если все слоты заняты
|
||
if (isNotSlotFree)
|
||
isSlotFree = false;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
//конец-------------------------------------Отправка пакетов на модем---------------------------------------------------
|
||
//конец-------------------------------------Отправка пакетов на модем---------------------------------------------------
|
||
//конец-------------------------------------Отправка пакетов на модем---------------------------------------------------
|
||
} else {
|
||
// Перенос файлов в отправленные
|
||
ToSentFiles(env, &fileSendInfo, path_dir_rep_fileName, path_dir_mask_fileName, path_dir_info_fileName);
|
||
}
|
||
|
||
|
||
// fr = f_findnext_i(env->fs, &dj, &fno);
|
||
|
||
mnum = getMaxUrgencyRepout(env);
|
||
}
|
||
// fr = f_closedir_i(env->fs, &dj);
|
||
|
||
if (isStopSend) {
|
||
bool resultStartSend = ModemStartSend(env);
|
||
if (resultStartSend)
|
||
env->modemWorkingState = MODEM_WORKING_MSG;
|
||
}
|
||
|
||
|
||
bool isSos = false;
|
||
|
||
fr = f_findfirst_i(env->fs, &dj, &fno, dir_rep_out, "*.INF");
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
uint32_t idFile = atoi(fno.fname);
|
||
|
||
createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
|
||
path_dir_mask_fileName,
|
||
path_dir_info_fileName,
|
||
(char *) dir_rep_out, idFile);
|
||
|
||
bool resultFileInfo = readSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
|
||
|
||
if (resultFileInfo == false) {
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
// Есть файл SOS
|
||
if (fileSendInfo.sos == 1) {
|
||
isSos = true;
|
||
}
|
||
|
||
// Поиск неотправленных блоков в файле маски
|
||
bool isFind;
|
||
if (isFindMaskPacketTransportIsNotProc(env->fs, &isFind, path_dir_mask_fileName) == false) {
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
if (isFind == false) {
|
||
// Перенос файлов в отправленные
|
||
ToSentFiles(env, &fileSendInfo, path_dir_rep_fileName, path_dir_mask_fileName, path_dir_info_fileName);
|
||
|
||
}
|
||
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(env->fs, &dj);
|
||
|
||
// Файлов SOS нет
|
||
if (isSos == false) {
|
||
if (env->store->nvm.flagSos == 1) {
|
||
env->store->nvm.flagSos = 0;
|
||
DeviceStorageCounterIni_DumpSos(env->store);
|
||
env->stateRequest.stateReqCreateExtW = StateReqExtForCreate;
|
||
env->stateRequest.stateReqCreateExtT = StateReqExtForCreate;
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
int isFilesRepOutInModem(tModemMain *env) {
|
||
// Запрос слотов передачи
|
||
RequestModemSendSlots(env);
|
||
|
||
for (int id = 0; id < 16; ++id) {
|
||
if (env->modemStatus.status[id] == SLOT_READY_READ_OR_WRITE) {
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
// Запуск задачи модема
|
||
void RunStopTaskModem(tModemMain *env) {
|
||
|
||
bool result1, result2, result3;
|
||
|
||
if (isFilesRepOutInModem(env) > 0) {
|
||
|
||
if (env->modemWorkingState != MODEM_WORKING_MSG) {
|
||
// Останов регистрации
|
||
result1 = StopRegTask(env);
|
||
// Останов альманаха
|
||
result2 = AlmaStop(env);
|
||
// Запуск передачи сообщений
|
||
result3 = ModemStartSend(env);
|
||
|
||
if ((result1) && (result2) && (result3))
|
||
env->modemWorkingState = MODEM_WORKING_MSG;
|
||
|
||
}
|
||
|
||
|
||
} else {
|
||
if (env->stateRequest.stateReqAlma == StateReqAlmaSendStatus) {
|
||
|
||
if (env->modemWorkingState != MODEM_WORKING_ALMA) {
|
||
// Останов задачи передачи сообщений
|
||
result1 = ModemStopSend(env);
|
||
// Останов регистрации
|
||
result2 = StopRegTask(env);
|
||
// Запуск альманаха
|
||
result3 = AlmaRun(env);
|
||
|
||
if ((result1) && (result2) && (result3))
|
||
env->modemWorkingState = MODEM_WORKING_ALMA;
|
||
|
||
}
|
||
|
||
|
||
} else {
|
||
if (env->stateRequest.stateReqReg == StateReqRegSendStatus) {
|
||
|
||
if (env->modemWorkingState != MODEM_WORKING_REG) {
|
||
// Останов передачи сообщений
|
||
result1 = ModemStopSend(env);
|
||
// Останов альманаха
|
||
result2 = AlmaStop(env);
|
||
// Запуск регистрации
|
||
result3 = StartRegTask(env);
|
||
|
||
if ((result1) && (result2) && (result3))
|
||
env->modemWorkingState = MODEM_WORKING_REG;
|
||
|
||
}
|
||
} else {
|
||
|
||
if (env->modemWorkingState != MODEM_WORKING_NONE) {
|
||
// Останов передачи сообщений
|
||
result1 = ModemStopSend(env);
|
||
// Останов альманаха
|
||
result2 = AlmaStop(env);
|
||
// Останов регистрации
|
||
result3 = StopRegTask(env);
|
||
|
||
if ((result1) && (result2) && (result3))
|
||
env->modemWorkingState = MODEM_WORKING_NONE;
|
||
|
||
}
|
||
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
// Количество файлов
|
||
int getCountFiles(tModemMain *env, char *path) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
|
||
int count = 0;
|
||
|
||
fr = f_findfirst_i(env->fs, &dj, &fno, path, "*.OTM");
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
++count;
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
}
|
||
|
||
fr = f_closedir_i(env->fs, &dj);
|
||
|
||
return count;
|
||
}
|
||
|
||
|
||
// Количество файлов в отправке
|
||
int getCountOutbox(tModemMain *env) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
FILINFO fnoInf;
|
||
FRESULT frInf;
|
||
tFileSendInfo fileSendInfo;
|
||
char path_dir_rep_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_mask_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_info_fileName[MAX_LEN_PATH_FS];
|
||
|
||
int count = 0;
|
||
|
||
fr = f_findfirst_i(env->fs, &dj, &fno, dir_rep_out, "*.INF");
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
uint32_t idFile = atoi(fno.fname);
|
||
|
||
createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
|
||
path_dir_mask_fileName,
|
||
path_dir_info_fileName,
|
||
(char *) dir_rep_out, idFile);
|
||
|
||
bool resultFileInfo = readSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
|
||
if (resultFileInfo == false) {
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
}
|
||
|
||
fr = f_closedir_i(env->fs, &dj);
|
||
|
||
return count;
|
||
}
|
||
|
||
|
||
// Котроль файлов в отправке и приеме
|
||
void controlFiles(tFs *fs, char *ext, char *path) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
|
||
char path_dir_rep_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_mask_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_info_fileName[MAX_LEN_PATH_FS];
|
||
|
||
fr = f_findfirst_i(fs, &dj, &fno, path, ext);
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
// Получение указателя на расширение файла
|
||
char *pExt = getVoidExt((char *) fno.fname);
|
||
|
||
if ((strcmp(pExt, ".REP") != 0) && (strcmp(pExt, ".INF") != 0) && (strcmp(pExt, ".MSK") != 0)) {
|
||
char path_fileName[MAX_LEN_PATH_FS];
|
||
path_fileName[0] = '\0';
|
||
|
||
strcat(path_fileName, path);
|
||
strcat(path_fileName, fno.fname);
|
||
|
||
fr = f_unlink_i(fs, path_fileName);
|
||
} else {
|
||
|
||
uint32_t idFile = atoi(fno.fname);
|
||
|
||
createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
|
||
path_dir_mask_fileName,
|
||
path_dir_info_fileName,
|
||
(char *) path, idFile);
|
||
|
||
FILINFO fnoInf;
|
||
FRESULT frInf = f_stat(path_dir_info_fileName, &fnoInf);
|
||
|
||
FILINFO fnoRep;
|
||
FRESULT frRep = f_stat(path_dir_rep_fileName, &fnoRep);
|
||
|
||
FILINFO fnoMsk;
|
||
FRESULT frMsk = f_stat(path_dir_mask_fileName, &fnoMsk);
|
||
|
||
if ((frRep) || (frMsk) || (frInf)) {
|
||
fr = f_unlink_i(fs, path_dir_rep_fileName);
|
||
fr = f_unlink_i(fs, path_dir_mask_fileName);
|
||
fr = f_unlink_i(fs, path_dir_info_fileName);
|
||
}
|
||
|
||
}
|
||
fr = f_findnext_i(fs, &dj, &fno);
|
||
}
|
||
|
||
fr = f_closedir_i(fs, &dj);
|
||
|
||
}
|
||
|
||
|
||
// Поиск и создание файла представления
|
||
bool CreateModemOutPaket(tFs *fs, tGonetsReedSalmon *gonetsReedSalmon, md5a_context *md5ctx, tRtcIO *rtcIo,
|
||
tTypeFile typeFile, tDeviceStorageIni *store, int32_t gr) {
|
||
// Имя файла исходящего сообщения
|
||
char out_fileName[MAX_LEN_PATH_FS];
|
||
// Полный путь с именем файла до файла исходящего сообщения
|
||
char path_out_fileName[MAX_LEN_PATH_FS];
|
||
// Структура содержащая информацию по исходящему сообщению
|
||
// tFileSendInfo fileSendInfo;
|
||
|
||
uint32_t id = 0;
|
||
|
||
// Контроль файлов в отправке
|
||
controlFiles(fs, "*", (char *) dir_rep_out);
|
||
|
||
// Поиск самого сообщения
|
||
if (typeFile == TYPE_FILE_TRACERT) {
|
||
id = getMaxUrgencyOutbox(fs, gonetsReedSalmon, md5ctx, rtcIo, (char *) dir_tracert, out_fileName,
|
||
path_out_fileName, typeFile, store, gr);
|
||
// } else if (typeFile == TYPE_FILE_KVITIN) {
|
||
// id = getMaxUrgencyOutbox(fs, gonetsReedSalmon, md5ctx, rtcIo, (char *) dir_kvitin, out_fileName,
|
||
// path_out_fileName, typeFile, store, gr);
|
||
} else {
|
||
id = getMaxUrgencyOutbox(fs, gonetsReedSalmon, md5ctx, rtcIo, (char *) dir_outbox, out_fileName,
|
||
path_out_fileName, typeFile, store, gr);
|
||
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
// Удаление файлов сообщения из отправки (контроль сравнения в отправке)
|
||
bool delRepoutMessage(tModemMain *env) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
FILINFO fnoInf;
|
||
FRESULT frInf;
|
||
tFileSendInfo fileSendInfo;
|
||
char fileNameInOutbox[MAX_LEN_PATH_FS];
|
||
char path_dir_rep_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_mask_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_info_fileName[MAX_LEN_PATH_FS];
|
||
|
||
char strId[MAX_LEN_PATH_FS];
|
||
strId[0] = '\0';
|
||
|
||
bool isDelModem = false;
|
||
|
||
fr = f_findfirst_i(env->fs, &dj, &fno, dir_rep_out, "*.INF");
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
uint32_t idFile = atoi(fno.fname);
|
||
|
||
createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
|
||
path_dir_mask_fileName,
|
||
path_dir_info_fileName,
|
||
(char *) dir_rep_out, idFile);
|
||
|
||
bool resultFileInfo = readSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
|
||
if (resultFileInfo == false) {
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
// Тип файла - сообщение
|
||
if (fileSendInfo.typeFile != TYPE_FILE_TRACERT) {
|
||
|
||
createFileNameForId(fileNameInOutbox, (char *) dir_outbox, fileSendInfo.mnum, "OTM");
|
||
|
||
// Если файл в исходящих не найден, то удаляем его
|
||
frInf = f_stat(fileNameInOutbox, &fnoInf);
|
||
if (frInf) {
|
||
|
||
for (int i = 0; i < 16; ++i) {
|
||
if (env->modemStatus.idMessage[i] == fileSendInfo.mnum) {
|
||
env->modemStatus.idMessage[i] = 0;
|
||
isDelModem = true;
|
||
char buffer[12];
|
||
utoa(i + 1, buffer, 10);
|
||
strcat(strId, buffer);
|
||
strcat(strId, ",");
|
||
}
|
||
}
|
||
|
||
fr = f_unlink_i(env->fs, path_dir_rep_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_mask_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_info_fileName);
|
||
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
// Тип файла - трассировка
|
||
if (fileSendInfo.typeFile == TYPE_FILE_TRACERT) {
|
||
|
||
createFileNameForId(fileNameInOutbox, (char *) dir_tracert, fileSendInfo.mnum, "OTM");
|
||
|
||
// Если файл в исходящих не найден, то удаляем его
|
||
frInf = f_stat(fileNameInOutbox, &fnoInf);
|
||
if (frInf) {
|
||
|
||
for (int i = 0; i < 16; ++i) {
|
||
if (env->modemStatus.idMessage[i] == fileSendInfo.mnum) {
|
||
env->modemStatus.idMessage[i] = 0;
|
||
isDelModem = true;
|
||
char buffer[12];
|
||
utoa(i + 1, buffer, 10);
|
||
strcat(strId, buffer);
|
||
strcat(strId, ",");
|
||
}
|
||
}
|
||
|
||
fr = f_unlink_i(env->fs, path_dir_rep_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_mask_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_info_fileName);
|
||
|
||
}
|
||
|
||
|
||
}
|
||
|
||
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(env->fs, &dj);
|
||
|
||
bool result = true;
|
||
|
||
// Отправка на модем команды удаления пакетов
|
||
if (isDelModem) {
|
||
strId[strlen(strId) - 1] = '\0';
|
||
|
||
//result = SlotClear(env, strId);
|
||
result = SlotClearNoStartTask(env, strId);
|
||
}
|
||
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
// Удаление файлов трассировки из отправки
|
||
bool delRepout(tModemMain *env, tTypeFile typeFile, bool isDelFiles, bool isAllFiles) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
tFileSendInfo fileSendInfo;
|
||
char path_dir_rep_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_mask_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_info_fileName[MAX_LEN_PATH_FS];
|
||
char strId[MAX_LEN_PATH_FS];
|
||
strId[0] = '\0';
|
||
|
||
bool isDelModem = false;
|
||
|
||
fr = f_findfirst_i(env->fs, &dj, &fno, dir_rep_out, "*.INF");
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
uint32_t idFile = atoi(fno.fname);
|
||
|
||
createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
|
||
path_dir_mask_fileName,
|
||
path_dir_info_fileName,
|
||
(char *) dir_rep_out, idFile);
|
||
|
||
bool resultFileInfo = readSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
|
||
if (resultFileInfo == false) {
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
// Тип файла - трассировка
|
||
if ((fileSendInfo.typeFile == typeFile) || (isAllFiles)) {
|
||
|
||
for (int i = 0; i < 16; ++i) {
|
||
if (env->modemStatus.idMessage[i] == fileSendInfo.mnum) {
|
||
env->modemStatus.idMessage[i] = 0;
|
||
isDelModem = true;
|
||
char buffer[12];
|
||
utoa(i + 1, buffer, 10);
|
||
strcat(strId, buffer);
|
||
strcat(strId, ",");
|
||
}
|
||
}
|
||
|
||
if (isDelFiles) {
|
||
fr = f_unlink_i(env->fs, path_dir_rep_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_mask_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_info_fileName);
|
||
}
|
||
}
|
||
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(env->fs, &dj);
|
||
|
||
bool result = true;
|
||
|
||
// Отправка на модем команды удаления пакетов
|
||
if (isDelModem) {
|
||
strId[strlen(strId) - 1] = '\0';
|
||
|
||
result = SlotClearNoStartTask(env, strId);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// Удаление самого старого файла
|
||
bool delRepoutOld(tModemMain *env) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
FILINFO fnoInf;
|
||
FRESULT frInf;
|
||
tFileSendInfo fileSendInfo;
|
||
char path_dir_rep_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_mask_fileName[MAX_LEN_PATH_FS];
|
||
char path_dir_info_fileName[MAX_LEN_PATH_FS];
|
||
char strId[MAX_LEN_PATH_FS];
|
||
strId[0] = '\0';
|
||
|
||
uint32_t minNum = 0xFFFFFFFF;
|
||
|
||
bool isDelModem = false;
|
||
|
||
fr = f_findfirst_i(env->fs, &dj, &fno, dir_rep_out, "*.INF");
|
||
|
||
char path_Old_fileName[MAX_LEN_PATH_FS];
|
||
path_Old_fileName[0] = '\0';
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
uint32_t idFile = atoi(fno.fname);
|
||
|
||
createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
|
||
path_dir_mask_fileName,
|
||
path_dir_info_fileName,
|
||
(char *) dir_rep_out, idFile);
|
||
|
||
bool resultFileInfo = readSendFileInfo(env->fs, &fileSendInfo, path_dir_info_fileName);
|
||
if (resultFileInfo == false) {
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
continue;
|
||
}
|
||
|
||
// Самый старый файл
|
||
frInf = f_stat(path_dir_rep_fileName, &fnoInf);
|
||
if (frInf == FR_OK) {
|
||
if (fileSendInfo.mnum < minNum) {
|
||
minNum = fileSendInfo.mnum;
|
||
}
|
||
}
|
||
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(env->fs, &dj);
|
||
|
||
|
||
createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
|
||
path_dir_mask_fileName,
|
||
path_dir_info_fileName,
|
||
(char *) dir_rep_out, minNum);
|
||
|
||
|
||
for (int i = 0; i < 16; ++i) {
|
||
if (env->modemStatus.idMessage[i] == minNum) {
|
||
env->modemStatus.idMessage[i] = 0;
|
||
isDelModem = true;
|
||
char buffer[12];
|
||
utoa(i + 1, buffer, 10);
|
||
strcat(strId, buffer);
|
||
strcat(strId, ",");
|
||
}
|
||
}
|
||
|
||
fr = f_unlink_i(env->fs, path_dir_rep_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_mask_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_info_fileName);
|
||
|
||
bool result = true;
|
||
|
||
// Отправка на модем команды удаления пакетов
|
||
if (isDelModem) {
|
||
strId[strlen(strId) - 1] = '\0';
|
||
|
||
result = SlotClearNoStartTask(env, strId);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// Удаление самого старого файла
|
||
bool delFilesOld(tModemMain *env, char *path) {
|
||
FRESULT fr;
|
||
DIR dj;
|
||
FILINFO fno;
|
||
FILINFO fnoInf;
|
||
FRESULT frInf;
|
||
|
||
uint32_t minNum = 0;
|
||
uint32_t minData = 0xFFFFFFFF;
|
||
uint32_t curDara = 0;
|
||
|
||
// char path_dir_rep_fileName[MAX_LEN_PATH_FS];
|
||
// char path_dir_mask_fileName[MAX_LEN_PATH_FS];
|
||
// char path_dir_info_fileName[MAX_LEN_PATH_FS];
|
||
|
||
|
||
char strId[MAX_LEN_PATH_FS];
|
||
strId[0] = '\0';
|
||
|
||
char path_fileName[MAX_LEN_PATH_FS];
|
||
path_fileName[0] = '\0';
|
||
|
||
bool isDelModem = false;
|
||
|
||
fr = f_findfirst_i(env->fs, &dj, &fno, path, "*.OTM");
|
||
|
||
while (fr == FR_OK && fno.fname[0]) {
|
||
|
||
uint32_t idFile = atoi(fno.fname);
|
||
createFileNameForId(path_fileName, (char *) path, idFile, "OTM");
|
||
|
||
// Самый старый файл
|
||
frInf = f_stat(path_fileName, &fnoInf);
|
||
if (frInf == FR_OK) {
|
||
curDara = fno.ftime | (fno.fdate << 16);
|
||
|
||
if (curDara < minData) {
|
||
minData = curDara;
|
||
minNum = idFile;
|
||
}
|
||
}
|
||
|
||
fr = f_findnext_i(env->fs, &dj, &fno);
|
||
}
|
||
fr = f_closedir_i(env->fs, &dj);
|
||
|
||
createFileNameForId(path_fileName, (char *) path, minNum, "OTM");
|
||
fr = f_unlink_i(env->fs, path_fileName);
|
||
createFileNameForId(path_fileName, (char *) path, minNum, "DAT");
|
||
fr = f_unlink_i(env->fs, path_fileName);
|
||
/*
|
||
createFileNameForId_REP_MSK_INF(path_dir_rep_fileName,
|
||
path_dir_mask_fileName,
|
||
path_dir_info_fileName,
|
||
(char *) dir_rep_out, minNum);
|
||
|
||
fr = f_unlink_i(env->fs, path_dir_rep_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_mask_fileName);
|
||
fr = f_unlink_i(env->fs, path_dir_info_fileName);
|
||
|
||
|
||
bool result = true;
|
||
|
||
for (int i = 0; i < 16; ++i) {
|
||
if (env->modemStatus.idMessage[i] == minNum) {
|
||
env->modemStatus.idMessage[i] = 0;
|
||
isDelModem = true;
|
||
char buffer[12];
|
||
utoa(i + 1, buffer, 10);
|
||
strcat(strId, buffer);
|
||
strcat(strId, ",");
|
||
}
|
||
}
|
||
|
||
// Отправка на модем команды удаления пакетов
|
||
if (isDelModem) {
|
||
strId[strlen(strId) - 1] = '\0';
|
||
|
||
result = SlotClearNoStartTask(env, strId);
|
||
}
|
||
|
||
|
||
return result;
|
||
*/
|
||
return true;
|
||
}
|
||
|
||
|
||
bool ModemMain_CreateOutFiles(tModemMain *env, tTypeFile typeFile, int32_t gr) {
|
||
bool result = true;
|
||
|
||
// Обработчик создания файлов представления
|
||
if (osMutexAcquire(env->accessMODEM, TIME_MUTEX_MODEM_ACCESS) == osOK) {
|
||
md5a_starts(&env->md5ctx_t);
|
||
result = CreateModemOutPaket(env->fs, &env->GonetsReedSalmonParity4, &env->md5ctx_t, env->rtcIo, typeFile,
|
||
env->store, gr);
|
||
osMutexRelease(env->accessMODEM);
|
||
} else {
|
||
return false;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
|
||
//начало -------------------------Контроль создания файлов сообщений----------------------------------------------------
|
||
//начало -------------------------Контроль создания файлов сообщений----------------------------------------------------
|
||
//начало -------------------------Контроль создания файлов сообщений----------------------------------------------------
|
||
void RequestSendMessagesModemSlots(tModemMain *env) {
|
||
|
||
// Если модем в передаче не передавать данные в модем
|
||
if (env->pwramp)
|
||
return;
|
||
|
||
bool isEdit = false;
|
||
|
||
// Контроль удаления файлов Сообщений
|
||
if (env->stateRequest.stateReqDelExtW == StateReqExtForDel) {
|
||
env->stateRequest.stateReqDelExtW = StateReqExtNone;
|
||
delRepoutMessage(env);
|
||
isEdit = true;
|
||
}
|
||
|
||
// Контроль удаления файлов Трассировки
|
||
if (env->stateRequest.stateReqDelExtT == StateReqExtForDel) {
|
||
env->stateRequest.stateReqDelExtT = StateReqExtNone;
|
||
delRepoutMessage(env);
|
||
|
||
if ((env->store->nvm.Settings_Tracert.PeSvCoor_v == 0) ||
|
||
(env->store->nvm.Settings_Tracert.mTracer_v == 0)) {
|
||
delRepout(env, TYPE_FILE_TRACERT, true, false);
|
||
} else {
|
||
env->stateRequest.stateReqCreateExtT = StateReqExtForCreate;
|
||
}
|
||
|
||
isEdit = true;
|
||
}
|
||
|
||
|
||
// Контроль создания файлов Сообщений
|
||
if (env->stateRequest.stateReqCreateExtW == StateReqExtForCreate) {
|
||
env->stateRequest.stateReqCreateExtW = StateReqExtNone;
|
||
|
||
ModemMain_CreateOutFiles(env, TYPE_FILE_MESSAGE, env->store->nvm.Settings_General.GMTcorr_v);
|
||
|
||
// Количество файлов в tracert
|
||
uint32_t count = getCountFiles(env, (char *) dir_outbox);
|
||
|
||
bool isDelFiles = false;
|
||
|
||
while (count > (maxFilesOutBox - 1)) {
|
||
|
||
// Удаление самого старого файла outbox
|
||
delFilesOld(env, (char *) dir_outbox);
|
||
isDelFiles = true;
|
||
|
||
// Количество файлов в outbox
|
||
count = getCountFiles(env, (char *) dir_outbox);
|
||
|
||
}
|
||
|
||
if (isDelFiles)
|
||
delRepoutMessage(env);
|
||
|
||
if (osMutexAcquire(env->accessHTTP, TIME_MUTEX_HTTP_ACCESS) == osOK) {
|
||
createBufStateFileSend(env->fs);
|
||
osMutexRelease(env->accessHTTP);
|
||
}
|
||
|
||
isEdit = true;
|
||
}
|
||
|
||
// Контроль создания файлов Трассировки
|
||
if (env->stateRequest.stateReqCreateExtT == StateReqExtForCreate) {
|
||
env->stateRequest.stateReqCreateExtT = StateReqExtNone;
|
||
|
||
/*
|
||
int step = 0;
|
||
// Количество файлов в отправке
|
||
uint32_t count = getCountOutbox(env, TYPE_FILE_TRACERT);
|
||
while (count > env->store->nvm.Settings_Tracert.cntPackExtCoord_v) {
|
||
// Удаление самого старого файла
|
||
delRepoutOld(env, TYPE_FILE_TRACERT);
|
||
// Количество файлов в отправке
|
||
count = getCountOutbox(env, TYPE_FILE_TRACERT);
|
||
|
||
++step;
|
||
if (step == 15)
|
||
break;
|
||
}
|
||
*/
|
||
|
||
/*
|
||
// Количество файлов в tracert
|
||
uint32_t count = getCountTracert(env);
|
||
|
||
while (count > 15) {
|
||
|
||
// Удаление самого старого файла tracert
|
||
delTracertOld(env);
|
||
|
||
// Количество файлов в tracert
|
||
count = getCountTracert(env);
|
||
|
||
}
|
||
*/
|
||
|
||
if ((env->store->nvm.Settings_Tracert.PeSvCoor_v != 0) &&
|
||
(env->store->nvm.Settings_Tracert.mTracer_v != 0)) {
|
||
|
||
if (osMutexAcquire(env->accessTracert, 2000) == osOK) {
|
||
|
||
// Создание файлов уровня представления
|
||
ModemMain_CreateOutFiles(env, TYPE_FILE_TRACERT, env->store->nvm.Settings_General.GMTcorr_v);
|
||
|
||
osMutexRelease(env->accessTracert);
|
||
}
|
||
}
|
||
|
||
isEdit = true;
|
||
}
|
||
|
||
if (isEdit) {
|
||
// Запрос слотов передачи
|
||
RequestModemSendSlots(env);
|
||
/*
|
||
// начало Тест
|
||
if (env->testOne) {
|
||
--env->testOne;
|
||
// начало Тест
|
||
for (int i = 0; i < 2; ++i) {
|
||
env->modemStatus.status[i] = SLOT_READY_SENDING;
|
||
}
|
||
// конец Тест
|
||
//env->state = 1;
|
||
}
|
||
// конец Тест
|
||
*/
|
||
|
||
// Обработчик создания исходящих пакетов в модем
|
||
bool result = HandlerModemOutPaket(env);
|
||
|
||
int step = 0;
|
||
|
||
// Если произошла ошибка: Обработчик создания исходящих пакетов в модем
|
||
while (env->modemSlotSendStatusReload) {
|
||
// Если модем в передаче не передавать данные в модем
|
||
if (env->pwramp)
|
||
break;
|
||
|
||
#ifdef DEBUG_MODEM
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Обнаружена ошибка в процедуре формирования исходящих сообщений\n")
|
||
LoggerInfoStatic(LOGGER, LOG_SIGN, "Повтор процедуры формирования исходящих сообщений\n")
|
||
#endif
|
||
SystemDelayMs(1000);
|
||
|
||
env->modemSlotSendStatusReload = false;
|
||
// Запрос слотов передачи
|
||
RequestModemSendSlots(env);
|
||
// Обработчик создания исходящих пакетов в модем
|
||
result = HandlerModemOutPaket(env);
|
||
|
||
++step;
|
||
if (step >= 3)
|
||
break;
|
||
}
|
||
|
||
// Запуск задач модема
|
||
RunStopTaskModem(env);
|
||
|
||
}
|
||
|
||
|
||
}
|
||
//конец --------------------------Контроль создания файлов сообщений----------------------------------------------------
|
||
//конец --------------------------Контроль создания файлов сообщений----------------------------------------------------
|
||
//конец --------------------------Контроль создания файлов сообщений----------------------------------------------------
|