Перенос на новую организацию GONEC

This commit is contained in:
cfif 2025-01-24 13:22:32 +03:00
commit bed7248aad
9 changed files with 1551 additions and 0 deletions

646
MainModesArbiter.c Normal file
View File

@ -0,0 +1,646 @@
#include <argz.h>
//
// Created by xemon on 19.09.22.
//
#include "MainModesArbiter_Private.h"
#include "Flash_MT29F2G01ABAGDWB.h"
#include "http_server.h"
#include "at32_emac.h"
#include "netconf.h"
//#include "BootJump.h"
#include "AtCmdCommonProtected.h"
#include <string.h>
#include "at32_sdio.h"
#include "ff.h"
#include "tcp_server.h"
#include "AtGsmSim800f.h"
#include "i2c_smbus.h"
#include "delay_sec.h"
#include "stdlib.h"
#include "MainModesArbiter.h"
#include "stdio.h"
#include "stdarg.h"
#include "at32f435_437_emac.h"
#define LOG_SIGN "Главн."
#define LOGGER &env->slog.logger
void TaskTcpLoop_Init(
tTaskTcpLoop *env
) {
//Инициализируем поток
InitThreadAtrStatic(&env->thread.attr, "TaskTcpLoop_Thread", env->thread.controlBlock, env->thread.stack,
osPriorityNormal);
env->thread.id = 0;
}
void sys_check_timeouts(void);
#include "lwip/stats.h"
extern tMma MAIN_ENV;
//#define LWIP_DEBUG 1
static _Noreturn void TaskTcpLoop_Thread(tTaskTcpLoop *env) {
for (;;) {
#ifdef LWIP_DEBUG
stats_display();
#endif
SystemDelayMs(5000);
}
}
char bufLwIpWebStats[4096];
uint32_t bufLwIpWebStepStats = 0;
// uprintf
// lwip_win32_platform_diag
int16_t uprintf(const char *fmt, ...) {
char bufLwIpStats[1024];
int16_t bufLwIpStatsLen = 0;
bufLwIpStatsLen = -1;
va_list ap;
#ifdef LWIP_DEBUG
char str[9];
// Вернет ошибку, если формат является указателем NULL:
if (!fmt) { return -1; }
// Вернет ошибку, если строка превышает размер буфера, с учетом
// необходимых дополнительных 2 символов: CR и нулевой терминатор ASCIIZ:
if (sizeof(bufLwIpStats) - 2 < strlen(fmt)) {
return -1;
}
va_start (ap, fmt);
bufLwIpStatsLen = vsprintf(bufLwIpStats, fmt, ap);
bufLwIpStats[bufLwIpStatsLen + 1] = 0;
va_end (ap);
for (int i = 0; i < bufLwIpStatsLen; ++i) {
bufLwIpWebStats[bufLwIpWebStepStats] = bufLwIpStats[i];
++bufLwIpWebStepStats;
if (bufLwIpWebStepStats >= sizeof(bufLwIpWebStats))
bufLwIpWebStepStats = 0;
}
// SerialPortTransmit(&MAIN_ENV.serialPorts->ComIntHalfDuplexIo, (uint8_t *) bufLwIpStats, bufLwIpStatsLen, 100);
// buf[0] = '\0';
// strcat(buf, "error summary: ");
// utoa((EMAC_DMARXDESC_ES), str, 10);
#endif
return bufLwIpStatsLen;
}
void TaskTcpLoop_StartThread(tTaskTcpLoop *env) {
if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (TaskTcpLoop_Thread), (void *) (env), &env->thread.attr);
} else {
osThreadResume(env->thread.id);
}
}
void Mma_Init(
tMma *env,
tGpios *gpios,
tAdcs *adcs,
tSerialPorts *serialPorts,
tSpiPorts *spiPorts,
tRtcs *rtcs,
tStorageOnFlash *flash,
tFirmwareLoader *firmwareMainLoader,
tFirmwareLoader *firmwareBootLoader
) {
env->gpios = gpios;
env->adcs = adcs;
env->serialPorts = serialPorts;
// env->i2cPorts = i2cPorts;
env->spiPorts = spiPorts;
env->rtcs = rtcs;
env->flash = flash;
env->firmwareMainLoader = firmwareMainLoader;
env->firmwareBootLoader = firmwareBootLoader;
InitThreadAtrStatic(&env->thread.attr, "Mma", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
env->thread.id = 0;
}
/*
void Mma_Shutdown(tMma *env) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Завершение работы")
VarsTabDumpObserver_Flush(&env->storage.dumpObserver);
LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение питания через 1с")
SystemDelayMs(1000);
Pwm_Blackout(&env->power);
LoggerInfoStatic(LOGGER, LOG_SIGN, "Питание осталось, обратите внимание!!")
LoggerInfoStatic(LOGGER, LOG_SIGN, "Возможно произошло повторное включение пользователем")
SystemDelayMs(5000);
BootJumpToAddress(0x8000000);
LoggerErrorStatic(LOGGER, LOG_SIGN, "Этой строчки не должно быть! Критическая ошибка!")
}
void Mma_CheckShutdown(tMma *env) {
if (Pwm_IsShutdownRequired(&env->power) && !(EraGlonassUveos_IsStandby(&env->uveos))) {
Mma_Shutdown(env);
}
}
void Mma_GaragMode(tMma *env) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Переход в режим Гараж")
Mma_SetMode(env, DEVICE_MODE_UVEOS_GARAG_MODE);
GpioPinEnable(&env->power.pins->main.garage);
EraGlonassUveos_GarageStarted(&env->uveos);
tUserInputButtonEvent buttonEvent;
while (1) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Режим Гараж")
GsmWithGnss_UpdateGnssData(&env->gsmWithGnss);
if (EraGlonassUveos_IsBreakGarage(&env->uveos)) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Автоматический выход из режима Гараж")
GpioPinDisable(&env->power.pins->main.garage);
GpioPinDisable(&env->power.pins->main.muteP);
break;
}
if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
if (UserInputButtonEventIsBetween(buttonEvent, UI_BUTTON_ADDITIONAL, RAISE, 3000, 0xFFFF)) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Пользовательский выход из режима Гараж")
GpioPinDisable(&env->power.pins->main.garage);
GpioPinDisable(&env->power.pins->main.muteP);
break;
}
}
SystemDelayMs(5000);
}
}
void Mma_RunTestingMode(tMma *env) {
LoggerTraceStatic(LOGGER, LOG_SIGN, "Включаем регистрацию в сети");
GsmWithGnss_SetNetworkRegistration(&env->gsmWithGnss, true);
//задаем режим и обновляем индикторы
Mma_SetMode(env, DEVICE_MODE_TESTING);
//выключаем индикацию
UserIndication_StopThread(&env->indication);
//запускаем режим тестирования с пользователем
DeviceTesting_MainTestingMode(&env->testing);
//включаем индикацию
UserIndication_StartThread(&env->indication);
}
static void Mma_NetworkAndAudioEnable(tMma *env) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Включаем регистрацию в сети");
GsmWithGnss_SetNetworkRegistration(&env->gsmWithGnss, true);
LoggerInfoStatic(LOGGER, LOG_SIGN, "Ждем сеть...");
if (GsmWithGnss_WaitNetworkRegistration(&env->gsmWithGnss)) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "зерегестрировались");
} else {
LoggerErrorStatic(LOGGER, LOG_SIGN, "нет сети");
};
LoggerInfoStatic(LOGGER, LOG_SIGN, "Включаем звук");
}
*/
extern osMessageQueueId_t EthDataQueue;
void EMAC_IRQHandler(void) {
while (emac_received_packet_size_get() != 0) {
lwip_pkt_set_queue_handle(EthDataQueue);
}
emac_dma_flag_clear(EMAC_DMA_RI_FLAG);
emac_dma_flag_clear(EMAC_DMA_NIS_FLAG);
/*
while (emac_received_packet_size_get() != 0) {
lwip_pkt_handle();
}
emac_dma_flag_clear(EMAC_DMA_RI_FLAG);
emac_dma_flag_clear(EMAC_DMA_NIS_FLAG);
*/
}
#include "JSONSettings.h"
//char buffer[2048];
extern tMma MAIN_ENV;
/*
void exint_line6_config(void) {
exint_init_type exint_init_struct;
crm_periph_clock_enable(CRM_SCFG_PERIPH_CLOCK, TRUE);
crm_periph_clock_enable(CRM_GPIOE_PERIPH_CLOCK, TRUE);
scfg_exint_line_config(SCFG_PORT_SOURCE_GPIOE, SCFG_PINS_SOURCE6);
exint_default_para_init(&exint_init_struct);
exint_init_struct.line_enable = TRUE;
exint_init_struct.line_mode = EXINT_LINE_INTERRUPUT;
exint_init_struct.line_select = EXINT_LINE_6;
exint_init_struct.line_polarity = EXINT_TRIGGER_BOTH_EDGE;
exint_init(&exint_init_struct);
NVIC_EnableIRQ(EXINT9_5_IRQn);
NVIC_SetPriority(EXINT9_5_IRQn, 0x54);
}
void EXINT9_5_IRQHandler(void) {
bool pwr = GpioPinGet(&MAIN_ENV.gpios->Power.gonec_pwr_amp);
if (pwr) {
GpioPinSet(&MAIN_ENV.gpios->Power.tx_pwr_en, true);
delay_ms(100);
sendI2c();
} else {
GpioPinSet(&MAIN_ENV.gpios->Power.tx_pwr_en, false);
}
if (exint_flag_get(EXINT_LINE_6) != RESET) {
exint_flag_clear(EXINT_LINE_6);
}
}
void exint_line2_config(void) {
exint_init_type exint_init_struct;
crm_periph_clock_enable(CRM_SCFG_PERIPH_CLOCK, TRUE);
crm_periph_clock_enable(CRM_GPIOE_PERIPH_CLOCK, TRUE);
scfg_exint_line_config(SCFG_PORT_SOURCE_GPIOE, SCFG_PINS_SOURCE2);
exint_default_para_init(&exint_init_struct);
exint_init_struct.line_enable = TRUE;
exint_init_struct.line_mode = EXINT_LINE_INTERRUPUT;
exint_init_struct.line_select = EXINT_LINE_2;
exint_init_struct.line_polarity = EXINT_TRIGGER_BOTH_EDGE;
exint_init(&exint_init_struct);
NVIC_EnableIRQ(EXINT2_IRQn);
NVIC_SetPriority(EXINT2_IRQn, 0x54);
}
bool isPrmModem = false;
void EXINT2_IRQHandler(void) {
bool isPrm = GpioPinGet(&MAIN_ENV.gpios->Power.gonec_is_prm);
if (isPrm) {
isPrmModem = true;
}
if (exint_flag_get(EXINT_LINE_2) != RESET) {
exint_flag_clear(EXINT_LINE_2);
}
}
*/
/*
void exint_line_2_6_config(void) {
exint_init_type exint_init_struct;
crm_periph_clock_enable(CRM_SCFG_PERIPH_CLOCK, TRUE);
crm_periph_clock_enable(CRM_GPIOE_PERIPH_CLOCK, TRUE);
scfg_exint_line_config(SCFG_PORT_SOURCE_GPIOE, SCFG_PINS_SOURCE2);
scfg_exint_line_config(SCFG_PORT_SOURCE_GPIOE, SCFG_PINS_SOURCE6);
exint_default_para_init(&exint_init_struct);
exint_init_struct.line_enable = TRUE;
exint_init_struct.line_mode = EXINT_LINE_INTERRUPUT;
exint_init_struct.line_select = EXINT_LINE_2 | EXINT_LINE_6;
exint_init_struct.line_polarity = EXINT_TRIGGER_BOTH_EDGE;
exint_init(&exint_init_struct);
NVIC_EnableIRQ(EXINT2_IRQn);
NVIC_SetPriority(EXINT2_IRQn, 0x54);
NVIC_EnableIRQ(EXINT9_5_IRQn);
NVIC_SetPriority(EXINT9_5_IRQn, 0x54);
}
void EXINT9_5_IRQHandler(void) {
bool pwr = GpioPinGet(&MAIN_ENV.gpios->Power.gonec_pwr_amp);
if (pwr) {
GpioPinSet(&MAIN_ENV.gpios->Power.tx_pwr_en, true);
delay_ms(100);
sendI2c();
} else {
GpioPinSet(&MAIN_ENV.gpios->Power.tx_pwr_en, false);
}
if (exint_flag_get(EXINT_LINE_6) != RESET) {
exint_flag_clear(EXINT_LINE_6);
}
}
bool isPrmModem = false;
void EXINT2_IRQHandler(void) {
bool isPrm = GpioPinGet(&MAIN_ENV.gpios->Power.gonec_is_prm);
if (isPrm) {
isPrmModem = true;
}
if (exint_flag_get(EXINT_LINE_2) != RESET) {
exint_flag_clear(EXINT_LINE_2);
}
}
*/
//uint8_t bufAnswer[40000];
//#define t1asm(tns) asm(".rept " #tns " ; nop ; .endr");
static _Noreturn void Mma_Thread(tMma *env) {
// t1asm(8 * 40);
// asm(".rept 1000 ; nop ; .endr");
// if (!DeviceStorage_Init(&env->storage, &env->flash->interface)) {
// Mma_FatalErrorOnInit(env, DEVICE_MODE_ERROR_FLASH);
// }
// env->storageIni.logger = &env->slog.logger;
// env->storage.dumpObserver.logger = &env->slog.logger;
// Сохранение настроек во временные
// NvmToRuntimeSettings();
// Перенастройка порта ComInt485
vSerialPort_ReInitUSART2(env->storageIni.nvm.Settings_RS485_Bluetooth.rs485baudrate_v);
env->accessHTTP = osMutexNew(NULL);
env->accessMODEM = osMutexNew(NULL);
env->accessLOG = osMutexNew(NULL);
env->accessLOG2 = osMutexNew(NULL);
env->accessTracert = osMutexNew(NULL);
env->accessMODEM_GSM = osMutexNew(NULL);
// Запуск устройства
Mma_InitStage(env);
// error_status status = emac_system_init_eth();
// while (status == ERROR);
// tcpip_stack_init();
httpd_init(&env->external, &env->rtcs->rtcI0, &env->taskAdc, &env->storageIni, &env->fs, env->spiPorts,
env->firmwareMainLoader,
env->firmwareBootLoader,
&env->modemMain,
env->accessHTTP, env->accessMODEM, env->accessLOG, env->accessLOG2, env->gpios, &env->flog,
&env->modemMainLog);
TaskTcpLoop_Init(&env->taskTcpLoop);
TaskTcpLoop_StartThread(&env->taskTcpLoop);
// exint_line_2_6_config();
// exint_line2_config();
// tcp_server_init();
// spi_flash_unblock(&env->spiPorts->flashSPI1IO, 1000);
// spi_flash_unblock(&env->spiPorts->flashSPI2IO, 1000);
// eDeviceModes indicationState;
// tUserInputButtonEvent buttonEvent;
// tUveosEmergencyEvent emergencyEvent;
// while (!EraGlonassUveos_IsEraAllowed(&env->uveos)) {
// Mma_SetMode(env, DEVICE_MODE_UVEOS_PASSIVE);
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Пассивный режим, сконфигурируйте устройство!")
// SystemDelayMs(3000);
// }
// Gsm_WaitStartup(&env->gsm);
// Mma_Network_Require(env);
// exint_line0_config();
//GpioPinSet(&env->gpios->comIntDir.transmit, true);
/*
FIL file;
UINT bytes_read;
int step = 0;
while (1) {
FRESULT fr = f_open_i(httpSettings.fs, &file, "1:/LOG2/31-05-23.LOG", FA_READ);
if (fr) {
asm("nop");
}
if (step == 1)
fr = f_lseek_i(httpSettings.fs, &file, 40000);
if (step == 2)
fr = f_lseek_i(httpSettings.fs, &file, 80000);
++step;
if (step == 3)
step = 0;
uint32_t t1 = SystemGetMs();
fr = f_read_i(httpSettings.fs, &file, bufAnswer, 40000, &bytes_read);
uint32_t t2 = SystemGetMs();
uint32_t t3 = t2 - t1;
if (t3 > 10) {
asm("nop");
}
f_close_i(httpSettings.fs, &file);
}
*/
volatile uint32_t stepPack = 0;
volatile uint32_t stepDiscardPack = 0;
for (;;) {
/*
struct pbuf *p = NULL;
osStatus_t status = osMessageQueueGet(EthDataQueue, &p, NULL, 100);
lwip_periodic_handle(SystemGetMs());
sys_check_timeouts();
if (status == osOK) {
//uint32_t t1 = SystemGetMs();
lwip_pkt_get_queue_handle(p);
//uint32_t t2 = SystemGetMs();
//uint32_t t3 = t2 - t1;
++stepPack;
} else {
++stepDiscardPack;
}
*/
lwip_periodic_handle(SystemGetMs());
sys_check_timeouts();
while (emac_received_packet_size_get() != 0) {
lwip_pkt_handle();
}
SystemDelayMs(1);
/*
LoggerTraceStatic(LOGGER, LOG_SIGN, "Начало итерации главного цикла")
LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем нужна ли сеть...")
if (EraGlonassUveos_IsRequireNetwork(&env->uveos)) {
LoggerTraceStatic(LOGGER, LOG_SIGN, "Нужна, подключаемся")
GsmWithGnss_SetNetworkRegistration(&env->gsmWithGnss, true);
} else {
LoggerTraceStatic(LOGGER, LOG_SIGN, "Ненужна, отключаемся")
GsmWithGnss_SetNetworkRegistration(&env->gsmWithGnss, false);
}
LoggerTraceStatic(LOGGER, LOG_SIGN, "Обновление ГНСС")
if (env->storage.runtime.enableGnssUpdate) {
GsmWithGnss_UpdateGnssData(&env->gsmWithGnss);
indicationState = GsmWithGnss_IsGnssReady(&env->gsmWithGnss) ?
DEVICE_MODE_UVEOS_ERA_GNSS_READY :
DEVICE_MODE_UVEOS_ERA_WAIT_GNSS;
} else {
indicationState = DEVICE_MODE_UVEOS_ERA_WAIT_GNSS;
}
LoggerTraceStatic(LOGGER, LOG_SIGN, "Выполняем постоянный тест")
if (DeviceTesting_Always(&env->testing)) {
indicationState = DEVICE_MODE_FAILURE;
};
LoggerTraceStatic(LOGGER, LOG_SIGN, "Выполняем периодическое тестирование")
DeviceTesting_Periodical(&env->testing);
LoggerTraceStatic(LOGGER, LOG_SIGN, "Обновляем индикацию")
Mma_SetMode(env, indicationState);
LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем экстренное событие")
if (UveosEmergencyEvent_GetNext(&env->crashDetect.emergencyEvents, &emergencyEvent, 0)) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Экстренное событие получено");
GpioPinEnable(&env->power.pins->main.ecall);
Mma_NetworkAndAudioEnable(env);
GpioPinDisable(&env->power.pins->main.ecall);
GpioPinDisable(&env->power.pins->main.muteP);
EraGlonassUveos_ProcessingEmergencyEvent(&env->uveos, &emergencyEvent);
}
LoggerTraceStatic(LOGGER, LOG_SIGN, "Проверяем нажатия кнопок")
if (UserButtons_GetNext(&env->userInput.buttonsInterface, &buttonEvent, 10)) {
if (UserInputButtonEventIsBetween(
buttonEvent, UI_BUTTON_EMERGENCY, RAISE, env->storage.nvm.gost.SOS_BUTTON_TIME, 0xFFFF
)) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Нажата кнопка экстренного вызова");
Mma_NetworkAndAudioEnable(env);
GpioPinEnable(&env->power.pins->main.ecall);
EraGlonassUveos_ManualEmergencyCall(&env->uveos);
GpioPinDisable(&env->power.pins->main.ecall);
GpioPinDisable(&env->power.pins->main.muteP);
}
if (UserInputButtonEventIsBetween(buttonEvent, UI_BUTTON_ADDITIONAL, RAISE, 3000, 10000)) {
Mma_NetworkAndAudioEnable(env);
Mma_RunTestingMode(env);
} else if (UserInputButtonEventIsBetween(buttonEvent, UI_BUTTON_ADDITIONAL, RAISE, 10000, 30000)) {
Mma_GaragMode(env);
}
}
Mma_CheckShutdown(env);
SystemDelayMs(10);
*/
}
}
void Mma_StartThread(tMma *env) {
if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Mma_Thread), (void *) (env), &env->thread.attr);
} else {
osThreadResume(env->thread.id);
}
}

159
MainModesArbiter.h Normal file
View File

@ -0,0 +1,159 @@
//
// Created by xemon on 19.09.22.
//
#ifndef UVEOS_ON_NATION_MMA_H
#define UVEOS_ON_NATION_MMA_H
//Железные интерфесы
#include "PeripheralInterfaces.h"
//Переферийные устройства
#include <DeviceStorageIni.h>
//#include <AudioCodec.h>
//#include <Accel.h>
//#include <GsmWithGnss.h>
//Подсистемы
#include <PowerManagement.h>
#include <LoggerToSerialPort.h>
#include <ComInt.h>
//#include <ComandLineInterface.h>
//#include <DeviceTesting.h>
//#include <CrashDetection.h>
//#include <EraGlonassUveos.h>
#include "cmsis_os.h"
#include "CmsisRtosThreadUtils.h"
#include "SystemDelayInterface.h"
#include "Rtcs.h"
#include "UserIndication.h"
#include "Gnss.h"
#include "ff.h"
#include "fs_interface.h"
#include <FirmwareLoader.h>
#include "Tracert.h"
#include "fs_base_func.h"
#include "ModemGonec.h"
#include "ModemMain.h"
#include "file_logger.h"
#include "ModemLog.h"
#include "TaskAdc.h"
#include "Gpios.h"
#include "Us.h"
#include "DeviceStorageIni.h"
#include "External.h"
#include "Modem_Timer.h"
#include "TaskMsd.h"
typedef struct {
struct {
osThreadId_t id;
uint32_t stack[4096];
StaticTask_t controlBlock;
osThreadAttr_t attr;
} thread;
} tTaskTcpLoop;
void TaskTcpLoop_Init(
tTaskTcpLoop *env
);
void TaskTcpLoop_StartThread(tTaskTcpLoop *env);
typedef struct {
// Преферийные интерфесы
tGpios *gpios;
tAdcs *adcs;
tSerialPorts *serialPorts;
tSpiPorts *spiPorts;
tStorageOnFlash *flash;
tRtcs *rtcs;
tFs fs;
tFirmwareLoader *firmwareMainLoader;
tFirmwareLoader *firmwareBootLoader;
osMutexId_t accessMODEM_GSM;
osMutexId_t accessHTTP;
osMutexId_t accessMODEM;
osMutexId_t accessLOG;
osMutexId_t accessLOG2;
osMutexId_t accessTracert;
// Преферийные устройства
// tDeviceStorage storage;
tDeviceStorageIni storageIni;
tPowerManagement power;
// tAudioCodec audioCodec;
// tGsmWithGnss gsmWithGnss;
// tAccel accel;
//Подсистемы
tFileLogger flog;
tFileLogger flog2;
tSerialPortIO flog_serial;
tSerialPortIO flog_serial2;
tLoggerToSerialPort slog;
tLoggerToSerialPort slog2;
// tUserInput userInput;
tUserIndication indication;
tComInt comInt;
// tCli cli;
// tCli cliVrt;
// tDeviceTesting testing;
// tCrashDetection crashDetect;
// tEraGlonassUveos uveos;
tGnss gnss;
tTaskTcpLoop taskTcpLoop;
tTaskAdc taskAdc;
tTracertMain tracertMain;
tExternal external;
tTaskMsd taskMsd;
tModemMain modemMain;
tModemMainLog modemMainLog;
tModemTimer modemTimer;
tUs us;
struct {
osThreadId_t id;
uint32_t stack[2048 * 2];
StaticTask_t controlBlock;
osThreadAttr_t attr;
} thread;
} tMma;
void Mma_Init(
tMma *env,
tGpios *gpios,
tAdcs *adcs,
tSerialPorts *serialPorts,
tSpiPorts *spiPorts,
tRtcs *rtcs,
tStorageOnFlash *flash,
tFirmwareLoader *firmwareMainLoader,
tFirmwareLoader *firmwareBootLoader
);
void Mma_StartThread(tMma *env);
#endif //UVEOS_ON_NATION_MMA_H

View File

@ -0,0 +1,416 @@
//
// Created by xemon on 11.12.22.
//
#include "MainModesArbiter_Private.h"
#define LOG_SIGN "Главн. Вкл"
#define LOGGER &env->slog.logger
static void Mma_InitSubSystems(tMma *env);
_Noreturn void Mma_FatalErrorOnInit(tMma *env, eDeviceModes errState) {
// Mma_SetMode(env, errState);
Mma_InitSubSystems(env);
ComInt_StartThread(&env->comInt);
for (;;) {
// Mma_CheckShutdown(env);
SystemDelayMs(1000);
}
}
static void Mma_InitPeripheralDevices(tMma *env) {
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация устройств...")
/*
GsmWithGnssInit(
&env->gsmWithGnss,
&env->serialPorts->TelitIO,
&env->storage.nvm.device.smsServiceCenter,
&env->storage.nvm.gost.GNSS_DATA_RATE
);
env->gsmWithGnss.logger = &env->slog.logger;
AudioCodecInit(&env->audioCodec, &env->i2cPorts->max9860Io, &env->storage.nvm.audioCodec);
Accel_Init(&env->accel, &env->spiPorts->accelIO);
*/
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация устройств завершена")
}
static void Mma_WaitGsmBoot(tMma *env) {
/*
while (!GsmWithGnssWaitStartup(&env->gsmWithGnss)) {
Mma_SetMode(env, DEVICE_MODE_ERROR_GSM);
}
uint32_t time = SystemGetMs() + 20000;
while (time > SystemGetMs()) {
if (GsmWithGnssInitGnss(&env->gsmWithGnss) == AT_OK) {
break;
}
}
GsmWithGnss_InitAudio(&env->gsmWithGnss);
*/
}
static void Mma_StartupAudioSubsystem(tMma *env) {
/*
Pwm_AudioEnable(&env->power);
GpioPinEnable(&env->power.pins->main.muteP);
while (!AudioCodecEnable(&env->audioCodec)) {
Mma_SetMode(env, DEVICE_MODE_ERROR_CODEC);
}
*/
}
static void Mma_StartupDevices(tMma *env) {
/*
LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск устройств...")
Accel_StartDevice(&env->accel);
LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск устройств завершен")
*/
}
extern void FS_Init(tFs *env);
void Mma_InitFs(tMma *env) {
FS_Init(&env->fs);
FRESULT res;
res = f_mkdir(dir_inbox);
res = f_mkdir(dir_outbox);
res = f_mkdir(dir_sentbox);
res = f_mkdir(dir_temp);
res = f_mkdir(dir_rep_out);
res = f_mkdir(dir_frag_inbox);
res = f_mkdir(dir_tracert);
res = f_mkdir(dir_kvitin);
res = f_mkdir(dir_web);
res = f_mkdir(dir_almhs);
res = f_mkdir(dir_logs);
res = f_mkdir(dir_logs2);
getDelFilesDirClean(&env->fs, (char *) dir_sentbox);
getDelFilesDirClean(&env->fs, (char *) dir_inbox);
// Удаление всех файлов трассировки
//delDirFileFs(&env->fs, (char *) dir_tracert);
// Удаление всех временных файлов
delDirFileFs(&env->fs, (char *) dir_temp);
char dirFileName[MAX_LEN_PATH_FS];
dirFileName[0] = '\0';
strcat(dirFileName, dir_logs);
strcat(dirFileName, "03-06-23.log");
FRESULT result = f_unlink_i(&env->fs, dirFileName);
dirFileName[0] = '\0';
strcat(dirFileName, dir_logs2);
strcat(dirFileName, "03-06-23.log");
result = f_unlink_i(&env->fs, dirFileName);
}
static void Mma_InitSubSystems(tMma *env) {
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация подсистем...")
ComInt_Init(
&env->comInt,
&env->serialPorts->ComIntHalfDuplexIo,
// &env->serialPorts->SIM800FIOSniffer,
&env->serialPorts->GONEC1IOSniffer,
&env->serialPorts->cliVirtualOutIo,
&env->indication.currentModeName
);
// Gsm_Init(&env->gsm, &env->serialPorts->SIM800FIO);
// env->gsm.logger = &env->slog.logger;
TaskAdc_Init(&env->taskAdc, env->adcs);
Gnss_Init(&env->gnss, &env->serialPorts->PRO04IO);
env->gnss.rtcIo = &env->rtcs->rtcI0;
env->gnss.GMTcorr_v = env->storageIni.nvm.Settings_General.GMTcorr_v;
env->gnss.logger = &env->slog.logger;
Us_Init(&env->us, env->gpios, &env->fs, &env->rtcs->rtcI0, &env->storageIni, &env->modemMain);
env->us.logger = &env->slog.logger;
ModemMainLog_Init(
&env->modemMainLog,
&env->storageIni,
&env->serialPorts->GONEC2IO,
&env->rtcs->rtcI0,
&env->fs,
env->accessLOG2
);
ModemMain_Init(
&env->modemMain,
env->gpios,
&env->serialPorts->GONEC1IO,
&env->serialPorts->SIM800FIO,
&env->gnss,
&env->storageIni,
&env->flog,
&env->fs,
&env->rtcs->rtcI0,
env->accessMODEM_GSM,
env->accessMODEM,
env->accessHTTP,
env->accessTracert
);
env->modemMain.logger = &env->slog.logger;
ModemTimer_Init(&env->modemTimer, &env->modemMain, &env->serialPorts->GONEC1IO, &env->flog, env->gpios);
env->modemTimer.logger = &env->slog.logger;
// TracertSensor_Init(
// &env->tracertSensor,
// &env->serialPorts->ComIntHalfDuplexIo,
// &env->storageIni
// );
TracertMain_Init(
&env->tracertMain,
&env->gnss,
&env->storageIni,
&env->external,
&env->fs,
&env->taskAdc,
&env->rtcs->rtcI0,
&env->modemMain,
env->accessTracert
);
env->tracertMain.logger = &env->slog.logger;
External_Init(&env->external,
&env->serialPorts->ComIntHalfDuplexIo,
// &env->serialPorts->ComInt232IO,
&env->storageIni,
&env->fs,
&env->rtcs->rtcI0,
&env->modemMain
);
env->external.logger = &env->slog.logger;
TaskMsd_Init(&env->taskMsd,
&env->gnss,
&env->rtcs->rtcI0,
&env->modemMain,
env->gpios
);
// env->storage.runtime.maxId_OutBox = getNameMaxFileId(&env->fs, (char *)dir_outbox, "*.OTM");
// InitMessagesTable(&env->fs, &env->storage.runtime.Box);
// InitMessagesKeysTable(&env->fs, &env->storage.runtime.Box);
/*
CrashDetection_Init(
&env->crashDetect,
&env->accel.accelDataFlow,
&env->storage.nvm.flip,
&env->slog.logger
);
EraGlonassUveos_Init(
&env->uveos,
&env->slog.logger,
&env->storage.nvm.msdTable,
&env->storage.nvm.gost,
&env->gsmWithGnss.navDataProvider,
&env->storage.uveosDumper,
&env->gsmWithGnss.ecallProvider,
&env->gsmWithGnss.smsProvider,
&env->userInput.buttonsInterface,
UI_BUTTON_EMERGENCY
);
ComInt_Init(
&env->comInt,
&env->serialPorts->ComIntHalfDuplexIo,
&env->storage,
&env->testing.testsTable,
&env->serialPorts->TelitIOSniffer,
&env->serialPorts->cliVirtualOutIo,
&env->indication.currentModeName
);
UserInput_Init(
&env->userInput,
&env->gpios->bip.buttons
);
DeviceTesting_Init(
&env->testing,
&env->gpios->power.main.ignition,
&env->adcs->gnssAntennaIo,
&env->adcs->speakerIo,
&env->adcs->batteryIo,
&env->gsmWithGnss.gsmAt,
&env->audioCodec,
&env->slog.logger,
&env->gsmWithGnss.audioPlayer,
&env->gsmWithGnss.audioRecorder,
&env->userInput.buttonsInterface,
&env->indication,
&env->uveos
);
Cli_Init(
&env->cli,
&env->serialPorts->DebugIO,
&env->serialPorts->TelitIOSniffer,
&env->storage.publicVariablesTable,
&env->crashDetect.carCrashDetection.flip,
&env->storage.nvm.msdTable,
&env->crashDetect.simulationInterface,
&env->userInput.watcher
);
Cli_Init(
&env->cliVrt,
&env->serialPorts->cliVirtualInIo,
NULL,
&env->storage.publicVariablesTable,
&env->crashDetect.carCrashDetection.flip,
&env->storage.nvm.msdTable,
&env->crashDetect.simulationInterface,
&env->userInput.watcher
);
*/
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализация подсистем завершена")
}
static void Mma_RunSubThreads(tMma *env) {
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Запуск субпотоков...")
// UserInput_StartThread(&env->userInput);
//ComInt_StartThread(&env->comInt);
// VarsTabDumpObserver_StartThread(&env->storage.dumpObserver);
// Accel_StartThread(&env->accel);
// CrashDetection_StartThread(&env->crashDetect);
// Cli_StartThread(&env->cli);
// Cli_StartThread(&env->cliVrt);
Gnss_StartThread(&env->gnss);
// TracertSensor_StartThread(&env->tracertSensor);
TracertMain_StartThread(&env->tracertMain);
External_StartThread(&env->external);
ModemMain_StartThread(&env->modemMain);
ModemMainLog_StartThread(&env->modemMainLog);
ModemTimer_StartThread(&env->modemTimer);
TaskAdc_StartThread(&env->taskAdc);
Us_StartThread(&env->us);
TaskMsd_StartThread(&env->taskMsd);
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Субпотоки запущены")
}
static void Mma_InitPower(tMma *env) {
Pwm_Init(&env->power, &env->gpios->Power, &env->gpios->SIM800FPower, &env->gpios->PRO04Power);
Pwm_Power(&env->power);
Pwm_SIM800FStartup(&env->power);
Pwm_PRO04Startup(&env->power);
}
static void Mma_InitLogger(tMma *env) {
FileLogger_Init(&env->flog, &env->storageIni, &env->fs, &env->rtcs->rtcI0, env->accessLOG, (char *) dir_logs);
env->flog_serial = FileLogger_GetSerialIo(&env->flog);
LoggerToSerialPort_Init(&env->slog, env->storageIni.nvm.Settings_General.GMTcorr_v, &env->flog_serial,
&env->rtcs->rtcI0, SERIAL_LOGGER_SHOW_TIME);
FileLogger_Init(&env->flog2, &env->storageIni, &env->fs, &env->rtcs->rtcI0, env->accessLOG2, (char *) dir_logs2);
env->flog_serial2 = FileLogger_GetSerialIo(&env->flog2);
LoggerToSerialPort_Init(&env->slog2, env->storageIni.nvm.Settings_General.GMTcorr_v, &env->flog_serial2,
&env->rtcs->rtcI0, 0);
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Начало логирования")
// env->storageIni.logger = &env->slog.logger;
// env->storage.dumpObserver.logger = &env->slog.logger;
}
static void Mma_InitAndRunIndication(tMma *env) {
UserIndication_Init(&env->indication, DEVICE_MODE_STARTUP);
// UserIndication_StartThread(&env->indication);
}
void Mma_InitStage(tMma *env) {
Mma_InitPower(env);
// Mma_InitFs(env);
Mma_InitLogger(env);
Mma_InitAndRunIndication(env);
// Mma_SetMode(env, DEVICE_MODE_STARTUP);
Mma_InitPeripheralDevices(env);
Mma_StartupDevices(env);
Mma_InitSubSystems(env);
Mma_RunSubThreads(env);
// Mma_SetMode(env, DEVICE_MODE_TESTING);
// if (DeviceTesting_OnIgnitionWithoutGsm(&env->testing)) {
// LoggerErrorStatic(LOGGER, LOG_SIGN, "Ошибка начального тестирования!!!")
// Mma_FatalErrorOnInit(env, DEVICE_MODE_ERROR_ON_INIT_TEST1);
// }
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Начальное тестирование ч.1 пройдено")
// Mma_SetMode(env, DEVICE_MODE_WAIT_GSM_BOOT);
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Ждем загрузку GSM...")
// Mma_WaitGsmBoot(env);
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Инициализируем звуковую подсистему(кодек,усилитель)")
// Mma_StartupAudioSubsystem(env);
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Обновляем настроку антены")
// GsmWithGnss_UseInternalAntenna(&env->gsmWithGnss, env->storage.nvm.device.useInternalAnt);
Mma_SetMode(env, DEVICE_MODE_UVEOS_ERA_WAIT_GNSS);
// if (DeviceTesting_OnIgnitionAfterGsm(&env->testing)) {
// Mma_FatalErrorOnInit(env, DEVICE_MODE_ERROR_ON_INIT_TEST2);
// LoggerErrorStatic(LOGGER, LOG_SIGN, "Ошибка начального тестирования!!!")
// }
// LoggerInfoStatic(LOGGER, LOG_SIGN, "Начальное тестирование ч.2 пройдено")
}

View File

@ -0,0 +1,19 @@
//
// Created by xemon on 11.12.22.
//
#ifndef UVEOS_ON_NATION_MAINMODESARBITER_PRIVATE_H
#define UVEOS_ON_NATION_MAINMODESARBITER_PRIVATE_H
#include "MainModesArbiter.h"
#define Mma_SetMode(ENV, VALUE) UserIndication_SetMode(&((ENV)->indication),(VALUE))
void Mma_FatalErrorOnInit(tMma *env, eDeviceModes errState);
void Mma_InitStage(tMma *env);
void Mma_CheckShutdown(tMma *env);
#endif //UVEOS_ON_NATION_MAINMODESARBITER_PRIVATE_H

13
PeripheralInterfaces.c Normal file
View File

@ -0,0 +1,13 @@
//
// Created by xemon on 11.12.22.
//
#include "PeripheralInterfaces.h"
void InitPeripheralInterfaces() {
Gpios_Init();
Adcs_Init();
SerialPorts_Init(&GPIOS.comIntDir);
SpiPorts_Init(&GPIOS.flashSPI);
Rtcs_Init();
StorageOnFlash_Init();
}

17
PeripheralInterfaces.h Normal file
View File

@ -0,0 +1,17 @@
//
// Created by xemon on 11.12.22.
//
#ifndef UVEOS_ON_ARTERY_DEVICE_PERIPHERALINTERFACES_H
#define UVEOS_ON_ARTERY_DEVICE_PERIPHERALINTERFACES_H
#include <Gpios.h>
#include "Adcs.h"
#include <SerialPorts.h>
#include <SpiPorts.h>
#include <StorageOnFlash.h>
#include "Rtcs.h"
void InitPeripheralInterfaces();
#endif //UVEOS_ON_ARTERY_DEVICE_PERIPHERALINTERFACES_H

232
Us.c Normal file
View File

@ -0,0 +1,232 @@
//
// Created by cfif on 14.04.23.
//
#include "Us.h"
#include "i2c_smbus.h"
#include "CmsisRtosThreadUtils.h"
#include "stdlib.h"
#include "ModemSend.h"
#include "ModemGonecFunc.h"
#define LOGGER env->logger
#define LOG_SIGN "GONEC"
void Us_Init(tUs *env, tGpios *gpios, tFs *fs, tRtcIO *rtcIo, tDeviceStorageIni *storage, tModemMain *ModemMain) {
env->gpios = gpios;
env->fs = fs;
env->rtcIo = rtcIo;
env->storage = storage;
env->ModemMain = ModemMain;
env->storage->runtime.almaError = true;
InitThreadAtrStatic(&env->thread.attr, "Us", env->thread.controlBlock, env->thread.stack, osPriorityNormal);
env->thread.id = 0;
}
static _Noreturn void Us_Thread(tUs *env) {
/*
bool startStuckGetMs = false;
uint32_t timeStuckGetMs = 0;
GpioPinSet(&env->gpios->Power.tx_pwr_en, false);
// Флаг проверки включения предусилиеля
bool FlagOnUs = true;
// Флаг проверки выключения предусилиеля
bool FlagOffUs = false;
*/
for (;;) {
if (env->ModemMain->location.isOneDateTime) {
SystemDelayMs(100);
continue;
}
/*
// Считывание состояния GPIO3 - Пин управления предусилителем
// Сообщает, когда включить или выключить предусилитель
env->pwrStatus = GpioPinGet(&env->gpios->Power.gonec_pwr_amp);
if ((env->pwrStatus) && (FlagOnUs)) {
// Фиксация уже включенного предусилителя
FlagOnUs = false;
FlagOffUs = true;
// Включение TX_PWR_En
GpioPinSet(&env->gpios->Power.tx_pwr_en, true);
// Ожидание инициализации устройства управления питанием
SystemDelayMs(80);
// Настройка источников питания, если процесс ВДРУГ завершился с ошибкой,
// в следующем цикле настройка питания повторяется
if (sendI2c()) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Включение предусилителя - успех");
} else {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Включение предусилителя - ошибка");
FlagOnUs = true;
FlagOffUs = false;
}
// Запуск контроля включения предусилителя
timeStuckGetMs = SystemGetMs();
startStuckGetMs = true;
}
if ((env->pwrStatus == false) && (FlagOffUs)) {
LoggerInfoStatic(LOGGER, LOG_SIGN, "Отключение предусилителя");
// Отключение TX_PWR_En
GpioPinSet(&env->gpios->Power.tx_pwr_en, false);
// Фиксация уже выключенного предусилителя
FlagOnUs = true;
FlagOffUs = false;
// Останов контроля включения предусилителя
startStuckGetMs = false;
}
// Проверка включенного предусилителя
if (startStuckGetMs) {
uint32_t dlStuckGetMs = SystemGetMs() - timeStuckGetMs;
// Если предусилитель включен больше 2 минут
if (dlStuckGetMs > 120000) {
char bufText[128];
bufText[0] = '\0';
strcat(bufText, "Контроль выключения предусилителя (");
utoa(env->pwrStatus, &bufText[strlen(bufText)], 10);
strcat(bufText, ",");
utoa(dlStuckGetMs, &bufText[strlen(bufText)], 10);
strcat(bufText, ",");
utoa(timeStuckGetMs, &bufText[strlen(bufText)], 10);
strcat(bufText, ")");
LoggerInfo(LOGGER, LOG_SIGN, bufText, strlen(bufText));
startStuckGetMs = false;
// Отключение TX_PWR_En
GpioPinSet(&env->gpios->Power.tx_pwr_en, false);
}
}
*/
bool isSos = getIsSlotsSos(env->ModemMain);
if ((env->storage->nvm.routing) || (isSos)) {
time_t now;
env->rtcIo->get(env->rtcIo, &now);
now += env->storage->nvm.Settings_General.GMTcorr_v * 3600;
bool almanacIsValid = GonetsAlmanac_IsValid(env->ModemMain->alms, now);
if ((env->ModemMain->countAlmanac == 0) || (almanacIsValid == false)) {
env->storage->runtime.almaError = true;
env->storage->nvm.routing = false;
env->storage->runtime.BannedSAT_ex[0] = '\0';
strcat(env->storage->runtime.BannedSAT_ex, env->storage->runtime.Settings_General.BannedSAT_v);
SetRoutingRestrictSc(env->ModemMain, env->storage->nvm.Settings_General.BannedSAT_v);
} else {
env->storage->runtime.almaError = false;
}
if (env->storage->runtime.almaError == false) {
uint8_t inRange[99]; // массив со спутниками внутри конуса
size_t countRange = 0;
uint32_t timeZoneInSat = env->storage->nvm.timeZoneInSat;
if (isSos)
timeZoneInSat = env->storage->nvm.Settings_Msd.SatTimeInZone;
uint32_t dist = env->storage->nvm.dist;
if (isSos)
dist = (uint32_t)GonetsAlmanac_GetDistanceByAngleDeg((float)env->storage->nvm.Settings_Msd.AlmSatAngle);
vector2 selfPosition;
selfPosition.x = (float) env->ModemMain->location.latitude;
selfPosition.y = (float) env->ModemMain->location.longitude;
//vector3 selfPosition = GeodesicToSpaceA(vc, 1500);
//time_t interval_begin = now - timeZoneInSat * 60;
time_t interval_begin = now;
time_t interval_end = now + timeZoneInSat * 60;
volatile uint32_t t1 = SystemGetMs();
countRange = GonetsAlmanac_GetInRangeForInterval(
env->ModemMain->alms,
(size_t) env->ModemMain->countAlmanac,
selfPosition,
(float) dist,
interval_begin,
interval_end,
inRange
);
volatile uint32_t t2 = SystemGetMs();
volatile uint32_t t3 = t2 - t1;
env->storage->runtime.BannedSAT_ex[0] = '\0';
strcat(env->storage->runtime.BannedSAT_ex, env->storage->runtime.Settings_General.BannedSAT_v);
for (int i = 0; i < env->ModemMain->countAlmanac; ++i) {
bool isFindKA = false;
for (size_t j = 0; j < countRange; ++j) {
if (env->ModemMain->alms[i].NKA == inRange[j]) {
isFindKA = true;
break;
}
}
if (isFindKA == false) {
if (strlen(env->storage->runtime.BannedSAT_ex) > 0)
strcat(env->storage->runtime.BannedSAT_ex, ",");
char buf[12];
utoa(env->ModemMain->alms[i].NKA, buf, 10);
strcat(env->storage->runtime.BannedSAT_ex, buf);
}
}
}
}
SystemDelayMs(30000);
// 10 мин
if (SystemGetMs() > osWaitForever - 600000) {
NVIC_SystemReset();
}
}
}
void Us_StartThread(tUs *env) {
if (!env->thread.id) {
env->thread.id = osThreadNew((osThreadFunc_t) (Us_Thread), (void *) (env), &env->thread.attr);
} else {
osThreadResume(env->thread.id);
}
}

39
Us.h Normal file
View File

@ -0,0 +1,39 @@
//
// Created by cfif on 14.04.23.
//
#ifndef GONEC_GSM_US_H
#define GONEC_GSM_US_H
#include "Gpios.h"
#include "file_logger.h"
#include "ModemMain.h"
typedef struct {
bool pwrStatus;
// bool prevPwrStatus;
tGpios *gpios;
tFs *fs;
tRtcIO *rtcIo;
tDeviceStorageIni *storage;
tModemMain *ModemMain;
// uint32_t startStuckGetMs;
// uint32_t timeStuckGetMs;
tLoggerInterface *logger;
struct {
osThreadId_t id;
uint32_t stack[2048 * 2];
StaticTask_t controlBlock;
osThreadAttr_t attr;
} thread;
} tUs;
void Us_Init(tUs *env, tGpios *gpios, tFs *fs, tRtcIO *rtcIo, tDeviceStorageIni *storage, tModemMain *ModemMain);
void Us_StartThread(tUs *env);
#endif //GONEC_GSM_US_H

10
modular.json Normal file
View File

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