906 lines
33 KiB
C
906 lines
33 KiB
C
#include "app_init/app_test.h"
|
|
#include "app_init/app_init.h"
|
|
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
|
|
#include "FreeRTOS.h"
|
|
#include "portable.h"
|
|
|
|
#include "flash_external_data.h"
|
|
#include "fm24cl16.h"
|
|
#include "app_rtc/app_rtc.h"
|
|
#include "usart.h"
|
|
#include "can.h"
|
|
#include "publicdata/publicdata.h"
|
|
#include "mylog/mylog.h"
|
|
#include "collect_ctrl/collect_task.h"
|
|
#include "sys_drv_init.h"
|
|
|
|
#define APP_TEST_LOG(fmt, ...) MYLOG_MSG(TASK_ID_MyLog, (fmt), ##__VA_ARGS__)
|
|
|
|
#ifndef APP_TEST_ENABLE
|
|
#define APP_TEST_ENABLE (0U)
|
|
#endif
|
|
|
|
#define APP_TEST_FLASH_ADDR (0x00010000U)
|
|
#define APP_TEST_FLASH_RW_SIZE (1024U)
|
|
#define APP_TEST_FLASH_PERIOD_S (10U)
|
|
#define APP_TEST_MIN_TEST_MS (1U)
|
|
#define APP_TEST_ALIGN (32U)
|
|
#define APP_TEST_GUARD_SIZE (32U)
|
|
#define APP_TEST_FLASH_TOTAL_32M (0x02000000U)
|
|
#define APP_TEST_FLASH_STEP_1M (0x00100000U)
|
|
#define APP_TEST_ENABLE_FLASH_SPEED (0U)
|
|
#define APP_TEST_EEPROM_ADDR (0x0600U)
|
|
#define APP_TEST_EEPROM_SIZE (32U)
|
|
|
|
#define APP_TEST_EEPROM_MULTI_SIZE (64U)
|
|
#define APP_TEST_EEPROM_SPEED_SIZE (64U)
|
|
#define APP_TEST_EEPROM_SPEED_LOOP (10U)
|
|
#define APP_TEST_EEPROM_SPEED_RETRY (3U)
|
|
/* Use dedicated test window, avoid business hot partitions (e.g. 0x0100/0x0400). */
|
|
#define APP_TEST_EEPROM_TEST_ADDR_BASE (0x0600U)
|
|
|
|
typedef enum
|
|
{
|
|
APP_TEST_STEP_RTC = 0,
|
|
APP_TEST_STEP_EEPROM_BASIC,
|
|
APP_TEST_STEP_EEPROM_MULTI,
|
|
APP_TEST_STEP_EEPROM_SPEED,
|
|
APP_TEST_STEP_CAN,
|
|
APP_TEST_STEP_UART,
|
|
#if (APP_TEST_ENABLE_FLASH_SPEED)
|
|
APP_TEST_STEP_FLASH_SPEED,
|
|
#endif
|
|
APP_TEST_STEP_FLASH_STRIDE,
|
|
APP_TEST_STEP_DONE
|
|
} APP_TEST_STEP_T;
|
|
|
|
#if (APP_TEST_ENABLE)
|
|
|
|
/**
|
|
* @brief 将指针向上对齐到指定字节边界。
|
|
* @param p 原始指针。
|
|
* @param align 对齐值（2 的幂）。
|
|
* @return 对齐后的指针。
|
|
*/
|
|
static uint8_t *align_up_u8(uint8_t *p, uint32_t align)
|
|
{
|
|
uintptr_t v = (uintptr_t)p;
|
|
v = (v + (align - 1U)) & ~(uintptr_t)(align - 1U);
|
|
return (uint8_t *)v;
|
|
}
|
|
|
|
/**
|
|
* @brief 为 Flash DMA 测试申请对齐缓冲。
|
|
* @param tx_raw 输出：TX 原始指针（用于释放）。
|
|
* @param rx_raw 输出：RX 原始指针（用于释放）。
|
|
* @param tx_buf 输出：对齐后的 TX 指针（用于读写）。
|
|
* @param rx_buf 输出：对齐后的 RX 指针（用于读写）。
|
|
* @return 1 成功，0 失败。
|
|
*/
|
|
static uint8_t app_test_alloc_aligned_buffers(uint8_t **tx_raw, uint8_t **rx_raw, uint8_t **tx_buf, uint8_t **rx_buf)
|
|
{
|
|
uint32_t alloc_size = APP_TEST_FLASH_RW_SIZE + APP_TEST_ALIGN + APP_TEST_GUARD_SIZE;
|
|
|
|
*tx_raw = (uint8_t *)pvPortMalloc(alloc_size);
|
|
*rx_raw = (uint8_t *)pvPortMalloc(alloc_size);
|
|
if ((*tx_raw == NULL) || (*rx_raw == NULL)) {
|
|
if (*tx_raw != NULL) {
|
|
vPortFree(*tx_raw);
|
|
}
|
|
if (*rx_raw != NULL) {
|
|
vPortFree(*rx_raw);
|
|
}
|
|
*tx_raw = NULL;
|
|
*rx_raw = NULL;
|
|
*tx_buf = NULL;
|
|
*rx_buf = NULL;
|
|
return 0U;
|
|
}
|
|
|
|
*tx_buf = align_up_u8(*tx_raw, APP_TEST_ALIGN);
|
|
*rx_buf = align_up_u8(*rx_raw, APP_TEST_ALIGN);
|
|
return 1U;
|
|
}
|
|
|
|
/**
|
|
* @brief 释放由 app_test_alloc_aligned_buffers 申请的原始缓冲。
|
|
* @param tx_raw TX 原始指针。
|
|
* @param rx_raw RX 原始指针。
|
|
*/
|
|
static void app_test_free_aligned_buffers(uint8_t *tx_raw, uint8_t *rx_raw)
|
|
{
|
|
if (tx_raw != NULL) {
|
|
vPortFree(tx_raw);
|
|
}
|
|
if (rx_raw != NULL) {
|
|
vPortFree(rx_raw);
|
|
}
|
|
}
|
|
|
|
#if (APP_TEST_ENABLE_FLASH_SPEED)
|
|
/**
|
|
* @brief 单次 Flash 擦写读回测速与校验。
|
|
* @details
|
|
* - 使用 1KB 数据块在固定地址做擦除/写入/读取；
|
|
* - 打印 erase/write/read 耗时与吞吐；
|
|
* - 读回校验失败会打印 seed 便于复现。
|
|
*/
|
|
static void v_app_test_flash_rw_speed_once(void)
|
|
{
|
|
uint32_t i;
|
|
uint64_t t0;
|
|
uint64_t t1;
|
|
uint32_t seed;
|
|
uint32_t erase_ms;
|
|
uint32_t write_ms;
|
|
uint32_t read_ms;
|
|
uint32_t write_kbs;
|
|
uint32_t read_kbs;
|
|
uint8_t *tx_raw;
|
|
uint8_t *rx_raw;
|
|
uint8_t *tx_buf;
|
|
uint8_t *rx_buf;
|
|
|
|
if (app_test_alloc_aligned_buffers(&tx_raw, &rx_raw, &tx_buf, &rx_buf) == 0U) {
|
|
APP_TEST_LOG("[APP_TEST] exflash malloc fail, size=%u\r\n", (unsigned int)APP_TEST_FLASH_RW_SIZE);
|
|
return;
|
|
}
|
|
|
|
seed = (uint32_t)u64_get_current_millis();
|
|
for (i = 0U; i < APP_TEST_FLASH_RW_SIZE; i++) {
|
|
tx_buf[i] = (uint8_t)((seed + i) & 0xFFU);
|
|
}
|
|
(void)memset(rx_buf, 0, APP_TEST_FLASH_RW_SIZE);
|
|
|
|
t0 = u64_get_current_millis();
|
|
(void)s32_flash_dataflash_erase_sector(APP_TEST_FLASH_ADDR);
|
|
t1 = u64_get_current_millis();
|
|
erase_ms = (uint32_t)(t1 - t0);
|
|
|
|
t0 = u64_get_current_millis();
|
|
(void)s32_flash_dataflash_write(APP_TEST_FLASH_ADDR, tx_buf, APP_TEST_FLASH_RW_SIZE);
|
|
t1 = u64_get_current_millis();
|
|
write_ms = (uint32_t)(t1 - t0);
|
|
if (write_ms < APP_TEST_MIN_TEST_MS) {
|
|
write_ms = APP_TEST_MIN_TEST_MS;
|
|
}
|
|
|
|
t0 = u64_get_current_millis();
|
|
(void)s32_flash_dataflash_read(APP_TEST_FLASH_ADDR, rx_buf, APP_TEST_FLASH_RW_SIZE);
|
|
t1 = u64_get_current_millis();
|
|
read_ms = (uint32_t)(t1 - t0);
|
|
if (read_ms < APP_TEST_MIN_TEST_MS) {
|
|
read_ms = APP_TEST_MIN_TEST_MS;
|
|
}
|
|
|
|
if (memcmp(tx_buf, rx_buf, APP_TEST_FLASH_RW_SIZE) != 0) {
|
|
APP_TEST_LOG("[APP_TEST] exflash rw verify fail, seed=%lu\r\n", (unsigned long)seed);
|
|
app_test_free_aligned_buffers(tx_raw, rx_raw);
|
|
return;
|
|
}
|
|
|
|
write_kbs = (APP_TEST_FLASH_RW_SIZE * 1000U) / (write_ms * 1024U);
|
|
read_kbs = (APP_TEST_FLASH_RW_SIZE * 1000U) / (read_ms * 1024U);
|
|
|
|
APP_TEST_LOG("[APP_TEST] exflash speed seed=%lu, erase=%lums, write=%lums(%luKB/s), read=%lums(%luKB/s)\r\n",
|
|
(unsigned long)seed,
|
|
(unsigned long)erase_ms,
|
|
(unsigned long)write_ms,
|
|
(unsigned long)write_kbs,
|
|
(unsigned long)read_ms,
|
|
(unsigned long)read_kbs);
|
|
|
|
app_test_free_aligned_buffers(tx_raw, rx_raw);
|
|
}
|
|
#endif
|
|
|
|
void v_app_test_rtc_rw_once(void)
|
|
{
|
|
Comm_Time backup_time;
|
|
Comm_Time write_time;
|
|
Comm_Time read_time;
|
|
|
|
GetCurrentTime(&backup_time);
|
|
|
|
write_time = backup_time;
|
|
write_time.ucSec = (uint8_t)((write_time.ucSec + 1U) % 60U);
|
|
if ((write_time.ucSec == 0U) && (write_time.ucMin < 59U)) {
|
|
write_time.ucMin++;
|
|
}
|
|
|
|
v_rtc_set_time(&write_time);
|
|
GetCurrentTime(&read_time);
|
|
|
|
APP_TEST_LOG("[APP_TEST] rtc rw test, write=%04u-%02u-%02u %02u:%02u:%02u, read=%04u-%02u-%02u %02u:%02u:%02u\r\n",
|
|
write_time.iYear, write_time.ucMonth, write_time.ucDay,
|
|
write_time.ucHour, write_time.ucMin, write_time.ucSec,
|
|
read_time.iYear, read_time.ucMonth, read_time.ucDay,
|
|
read_time.ucHour, read_time.ucMin, read_time.ucSec);
|
|
|
|
v_rtc_set_time(&backup_time);
|
|
}
|
|
|
|
#if defined(__CC_ARM)
|
|
#pragma diag_suppress 177
|
|
#endif
|
|
|
|
/**
|
|
* @brief EEPROM(FM24CL16) 单次读写校验测试。
|
|
* @return 1 通过，0 失败。
|
|
*/
|
|
uint8_t u8_app_test_eeprom_rw_once(void)
|
|
{
|
|
uint8_t tx[APP_TEST_EEPROM_SIZE];
|
|
uint8_t rx[APP_TEST_EEPROM_SIZE];
|
|
uint32_t i;
|
|
int32_t first_mismatch = -1;
|
|
uint8_t probe_ret;
|
|
uint32_t err_after_write;
|
|
uint32_t err_after_read;
|
|
uint8_t pr;
|
|
|
|
APP_TEST_LOG("[APP_TEST] eeprom rw test start, addr=0x%02X size=%u\r\n",
|
|
(unsigned int)APP_TEST_EEPROM_ADDR,
|
|
(unsigned int)APP_TEST_EEPROM_SIZE);
|
|
|
|
for (i = 0U; i < APP_TEST_EEPROM_SIZE; i++) {
|
|
tx[i] = (uint8_t)(0xA0U + i);
|
|
}
|
|
(void)memset(rx, 0, sizeof(rx));
|
|
|
|
probe_ret = eeprom_probe((uint16_t)APP_TEST_EEPROM_ADDR);
|
|
APP_TEST_LOG("[APP_TEST] eeprom probe ret=%u last_err=%lu\r\n",
|
|
(unsigned int)probe_ret,
|
|
(unsigned long)eeprom_get_last_error());
|
|
|
|
/* quick probe different blocks to verify dev-addr mapping */
|
|
pr = eeprom_probe(0x0000U);
|
|
APP_TEST_LOG("[APP_TEST] eeprom probe @0x0000 ret=%u err=%lu\r\n",
|
|
(unsigned int)pr, (unsigned long)eeprom_get_last_error());
|
|
pr = eeprom_probe(0x0100U);
|
|
APP_TEST_LOG("[APP_TEST] eeprom probe @0x0100 ret=%u err=%lu\r\n",
|
|
(unsigned int)pr, (unsigned long)eeprom_get_last_error());
|
|
pr = eeprom_probe(0x0200U);
|
|
APP_TEST_LOG("[APP_TEST] eeprom probe @0x0200 ret=%u err=%lu\r\n",
|
|
(unsigned int)pr, (unsigned long)eeprom_get_last_error());
|
|
pr = eeprom_probe(0x0700U);
|
|
APP_TEST_LOG("[APP_TEST] eeprom probe @0x0700 ret=%u err=%lu\r\n",
|
|
(unsigned int)pr, (unsigned long)eeprom_get_last_error());
|
|
|
|
eeprom_buffer_write(tx, (uint16_t)APP_TEST_EEPROM_ADDR, (uint16_t)APP_TEST_EEPROM_SIZE);
|
|
err_after_write = eeprom_get_last_error();
|
|
eeprom_buffer_read(rx, (uint16_t)APP_TEST_EEPROM_ADDR, (uint16_t)APP_TEST_EEPROM_SIZE);
|
|
err_after_read = eeprom_get_last_error();
|
|
|
|
if (memcmp(tx, rx, APP_TEST_EEPROM_SIZE) != 0) {
|
|
for (i = 0U; i < APP_TEST_EEPROM_SIZE; i++) {
|
|
if (tx[i] != rx[i]) {
|
|
first_mismatch = (int32_t)i;
|
|
break;
|
|
}
|
|
}
|
|
APP_TEST_LOG("[APP_TEST] eeprom rw verify fail, addr=0x%02X size=%u\r\n",
|
|
(unsigned int)APP_TEST_EEPROM_ADDR,
|
|
(unsigned int)APP_TEST_EEPROM_SIZE);
|
|
APP_TEST_LOG("[APP_TEST] eeprom err write=%lu read=%lu\r\n",
|
|
(unsigned long)err_after_write,
|
|
(unsigned long)err_after_read);
|
|
APP_TEST_LOG("[APP_TEST] eeprom dump first16 @0x%02X:\r\n",
|
|
(unsigned int)APP_TEST_EEPROM_ADDR);
|
|
for (i = 0U; i < 16U; i++) {
|
|
APP_TEST_LOG(" [%02u] wr=0x%02X rd=0x%02X\r\n",
|
|
(unsigned int)i,
|
|
(unsigned int)tx[i],
|
|
(unsigned int)rx[i]);
|
|
}
|
|
if (first_mismatch >= 0) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom mismatch idx=%ld wr=0x%02X rd=0x%02X\r\n",
|
|
(long)first_mismatch,
|
|
(unsigned int)tx[(uint32_t)first_mismatch],
|
|
(unsigned int)rx[(uint32_t)first_mismatch]);
|
|
}
|
|
return 0U;
|
|
}
|
|
|
|
APP_TEST_LOG("[APP_TEST] eeprom rw verify pass, addr=0x%02X size=%u\r\n",
|
|
(unsigned int)APP_TEST_EEPROM_ADDR,
|
|
(unsigned int)APP_TEST_EEPROM_SIZE);
|
|
return 1U;
|
|
}
|
|
|
|
/**
|
|
* @brief EEPROM 多地址点读写校验（覆盖关键分区起点与页边界）。
|
|
* @return 1 通过，0 失败。
|
|
*/
|
|
uint8_t u8_app_test_eeprom_multi_addr_rw_once(void)
|
|
{
|
|
static const uint16_t rw_addrs[] = {
|
|
0x0000U,
|
|
0x0040U,
|
|
0x0070U,
|
|
0x0080U,
|
|
0x00C0U,
|
|
0x00E0U,
|
|
0x00F0U,
|
|
0x0580U,
|
|
0x0600U,
|
|
0x0680U,
|
|
0x07C0U
|
|
};
|
|
static const uint16_t observe_addrs[] = {
|
|
(uint16_t)EEPROM_ADDR_HISALARM_MNG,
|
|
(uint16_t)EEPROM_ADDR_CARD_MNG,
|
|
(uint16_t)EEPROM_ADDR_A_LOG_DATA,
|
|
(uint16_t)EEPROM_ADDR_B_LOG_DATA
|
|
};
|
|
|
|
uint8_t tx[APP_TEST_EEPROM_MULTI_SIZE];
|
|
uint8_t rx[APP_TEST_EEPROM_MULTI_SIZE];
|
|
uint8_t bk[APP_TEST_EEPROM_MULTI_SIZE];
|
|
uint32_t i;
|
|
uint32_t a;
|
|
uint16_t addr;
|
|
|
|
for (i = 0U; i < APP_TEST_EEPROM_MULTI_SIZE; i++) {
|
|
tx[i] = (uint8_t)(0x55U ^ (uint8_t)i);
|
|
}
|
|
|
|
APP_TEST_LOG("[APP_TEST] eeprom multi-addr rw test start, size=%u, points=%u\r\n",
|
|
(unsigned int)APP_TEST_EEPROM_MULTI_SIZE,
|
|
(unsigned int)(sizeof(rw_addrs) / sizeof(rw_addrs[0])));
|
|
|
|
for (a = 0U; a < (uint32_t)(sizeof(rw_addrs) / sizeof(rw_addrs[0])); a++) {
|
|
addr = rw_addrs[a];
|
|
if (!EEPROM_ADDR_IN_RANGE(addr) || !EEPROM_ADDR_IN_RANGE((uint16_t)(addr + APP_TEST_EEPROM_MULTI_SIZE - 1U))) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom multi-addr skip out-of-range addr=0x%04X\r\n",
|
|
(unsigned int)addr);
|
|
continue;
|
|
}
|
|
|
|
(void)memset(rx, 0, sizeof(rx));
|
|
(void)memset(bk, 0, sizeof(bk));
|
|
|
|
/* backup original content to avoid corrupting real partitions */
|
|
eeprom_buffer_read(bk, addr, (uint16_t)APP_TEST_EEPROM_MULTI_SIZE);
|
|
if (eeprom_get_last_error() != 0U) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom multi-addr backup read fail addr=0x%04X err=%lu\r\n",
|
|
(unsigned int)addr, (unsigned long)eeprom_get_last_error());
|
|
return 0U;
|
|
}
|
|
|
|
eeprom_buffer_write(tx, addr, (uint16_t)APP_TEST_EEPROM_MULTI_SIZE);
|
|
if (eeprom_get_last_error() != 0U) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom multi-addr write fail addr=0x%04X err=%lu\r\n",
|
|
(unsigned int)addr, (unsigned long)eeprom_get_last_error());
|
|
/* best-effort restore */
|
|
eeprom_buffer_write(bk, addr, (uint16_t)APP_TEST_EEPROM_MULTI_SIZE);
|
|
return 0U;
|
|
}
|
|
eeprom_buffer_read(rx, addr, (uint16_t)APP_TEST_EEPROM_MULTI_SIZE);
|
|
if (eeprom_get_last_error() != 0U) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom multi-addr read fail addr=0x%04X err=%lu\r\n",
|
|
(unsigned int)addr, (unsigned long)eeprom_get_last_error());
|
|
/* best-effort restore */
|
|
eeprom_buffer_write(bk, addr, (uint16_t)APP_TEST_EEPROM_MULTI_SIZE);
|
|
return 0U;
|
|
}
|
|
|
|
if (memcmp(tx, rx, APP_TEST_EEPROM_MULTI_SIZE) != 0) {
|
|
for (i = 0U; i < APP_TEST_EEPROM_MULTI_SIZE; i++) {
|
|
if (tx[i] != rx[i]) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom multi-addr mismatch addr=0x%04X idx=%lu wr=0x%02X rd=0x%02X\r\n",
|
|
(unsigned int)addr,
|
|
(unsigned long)i,
|
|
(unsigned int)tx[i],
|
|
(unsigned int)rx[i]);
|
|
break;
|
|
}
|
|
}
|
|
/* restore original before returning */
|
|
eeprom_buffer_write(bk, addr, (uint16_t)APP_TEST_EEPROM_MULTI_SIZE);
|
|
return 0U;
|
|
}
|
|
APP_TEST_LOG("[APP_TEST] eeprom multi-addr pass addr=0x%04X\r\n", (unsigned int)addr);
|
|
|
|
/* restore original content */
|
|
eeprom_buffer_write(bk, addr, (uint16_t)APP_TEST_EEPROM_MULTI_SIZE);
|
|
if (eeprom_get_last_error() != 0U) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom multi-addr restore fail addr=0x%04X err=%lu\r\n",
|
|
(unsigned int)addr, (unsigned long)eeprom_get_last_error());
|
|
return 0U;
|
|
}
|
|
}
|
|
|
|
/* Observe-only check for business hot partitions (no write/restore). */
|
|
for (a = 0U; a < (uint32_t)(sizeof(observe_addrs) / sizeof(observe_addrs[0])); a++) {
|
|
addr = observe_addrs[a];
|
|
if (!EEPROM_ADDR_IN_RANGE(addr) || !EEPROM_ADDR_IN_RANGE((uint16_t)(addr + APP_TEST_EEPROM_MULTI_SIZE - 1U))) {
|
|
continue;
|
|
}
|
|
(void)memset(bk, 0, sizeof(bk));
|
|
eeprom_buffer_read(bk, addr, (uint16_t)APP_TEST_EEPROM_MULTI_SIZE);
|
|
if (eeprom_get_last_error() != 0U) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom multi-addr observe fail addr=0x%04X err=%lu\r\n",
|
|
(unsigned int)addr, (unsigned long)eeprom_get_last_error());
|
|
return 0U;
|
|
}
|
|
APP_TEST_LOG("[APP_TEST] eeprom multi-addr observe pass addr=0x%04X\r\n", (unsigned int)addr);
|
|
}
|
|
|
|
APP_TEST_LOG("[APP_TEST] eeprom multi-addr rw test pass\r\n");
|
|
return 1U;
|
|
}
|
|
|
|
/**
|
|
* @brief EEPROM 读写速度测试（循环读写固定大小并统计吞吐）。
|
|
* @return 1 通过，0 失败。
|
|
*/
|
|
uint8_t u8_app_test_eeprom_speed_once(void)
|
|
{
|
|
uint8_t tx[APP_TEST_EEPROM_SPEED_SIZE];
|
|
uint8_t rx[APP_TEST_EEPROM_SPEED_SIZE];
|
|
uint8_t bk[APP_TEST_EEPROM_SPEED_SIZE];
|
|
uint32_t i;
|
|
uint32_t j;
|
|
uint32_t r;
|
|
int32_t first_mismatch;
|
|
uint64_t t0;
|
|
uint64_t t1;
|
|
uint64_t write_ms;
|
|
uint64_t read_ms;
|
|
uint32_t write_kbs;
|
|
uint32_t read_kbs;
|
|
uint32_t loops = APP_TEST_EEPROM_SPEED_LOOP;
|
|
uint16_t addr = (uint16_t)APP_TEST_EEPROM_TEST_ADDR_BASE;
|
|
|
|
if (!EEPROM_ADDR_IN_RANGE(addr) || !EEPROM_ADDR_IN_RANGE((uint16_t)(addr + APP_TEST_EEPROM_SPEED_SIZE - 1U))) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom speed addr out-of-range\r\n");
|
|
return 0U;
|
|
}
|
|
|
|
for (i = 0U; i < APP_TEST_EEPROM_SPEED_SIZE; i++) {
|
|
tx[i] = (uint8_t)(i & 0xFFU);
|
|
}
|
|
|
|
APP_TEST_LOG("[APP_TEST] eeprom speed test start, addr=0x%04X size=%u loop=%u\r\n",
|
|
(unsigned int)addr,
|
|
(unsigned int)APP_TEST_EEPROM_SPEED_SIZE,
|
|
(unsigned int)loops);
|
|
|
|
/* backup original test window and restore at the end */
|
|
(void)memset(bk, 0, sizeof(bk));
|
|
eeprom_buffer_read(bk, addr, (uint16_t)APP_TEST_EEPROM_SPEED_SIZE);
|
|
if (eeprom_get_last_error() != 0U) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom speed backup read fail err=%lu\r\n",
|
|
(unsigned long)eeprom_get_last_error());
|
|
return 0U;
|
|
}
|
|
|
|
t0 = u64_get_current_millis();
|
|
for (i = 0U; i < loops; i++) {
|
|
for (r = 0U; r < APP_TEST_EEPROM_SPEED_RETRY; r++) {
|
|
eeprom_buffer_write(tx, addr, (uint16_t)APP_TEST_EEPROM_SPEED_SIZE);
|
|
if (eeprom_get_last_error() == 0U) {
|
|
break;
|
|
}
|
|
vTaskDelay(pdMS_TO_TICKS(2U));
|
|
}
|
|
if (eeprom_get_last_error() != 0U) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom speed write fail loop=%lu retry=%lu err=%lu\r\n",
|
|
(unsigned long)i,
|
|
(unsigned long)r,
|
|
(unsigned long)eeprom_get_last_error());
|
|
eeprom_buffer_write(bk, addr, (uint16_t)APP_TEST_EEPROM_SPEED_SIZE);
|
|
return 0U;
|
|
}
|
|
/* Allow write cycle settle time under stress loops. */
|
|
vTaskDelay(pdMS_TO_TICKS(2U));
|
|
}
|
|
t1 = u64_get_current_millis();
|
|
write_ms = (t1 >= t0) ? (t1 - t0) : 0U;
|
|
if (write_ms < APP_TEST_MIN_TEST_MS) {
|
|
write_ms = APP_TEST_MIN_TEST_MS;
|
|
}
|
|
|
|
t0 = u64_get_current_millis();
|
|
for (i = 0U; i < loops; i++) {
|
|
for (r = 0U; r < APP_TEST_EEPROM_SPEED_RETRY; r++) {
|
|
(void)memset(rx, 0, sizeof(rx));
|
|
eeprom_buffer_read(rx, addr, (uint16_t)APP_TEST_EEPROM_SPEED_SIZE);
|
|
if ((eeprom_get_last_error() == 0U) &&
|
|
(memcmp(tx, rx, APP_TEST_EEPROM_SPEED_SIZE) == 0)) {
|
|
break;
|
|
}
|
|
vTaskDelay(pdMS_TO_TICKS(2U));
|
|
}
|
|
|
|
if ((eeprom_get_last_error() != 0U) || (memcmp(tx, rx, APP_TEST_EEPROM_SPEED_SIZE) != 0)) {
|
|
first_mismatch = -1;
|
|
for (j = 0U; j < APP_TEST_EEPROM_SPEED_SIZE; j++) {
|
|
if (tx[j] != rx[j]) {
|
|
first_mismatch = (int32_t)j;
|
|
break;
|
|
}
|
|
}
|
|
if (first_mismatch >= 0) {
|
|
APP_TEST_LOG("[APP_TEST] eeprom speed verify fail loop=%lu retry=%lu idx=%ld wr=0x%02X rd=0x%02X err=%lu\r\n",
|
|
(unsigned long)i,
|
|
(unsigned long)r,
|
|
(long)first_mismatch,
|
|
(unsigned int)tx[(uint32_t)first_mismatch],
|
|
(unsigned int)rx[(uint32_t)first_mismatch],
|
|
(unsigned long)eeprom_get_last_error());
|
|
} else {
|
|
APP_TEST_LOG("[APP_TEST] eeprom speed verify fail loop=%lu retry=%lu err=%lu\r\n",
|
|
(unsigned long)i,
|
|
(unsigned long)r,
|
|
(unsigned long)eeprom_get_last_error());
|
|
}
|
|
eeprom_buffer_write(bk, addr, (uint16_t)APP_TEST_EEPROM_SPEED_SIZE);
|
|
return 0U;
|
|
}
|
|
}
|
|
t1 = u64_get_current_millis();
|
|
read_ms = (t1 >= t0) ? (t1 - t0) : 0U;
|
|
if (read_ms < APP_TEST_MIN_TEST_MS) {
|
|
read_ms = APP_TEST_MIN_TEST_MS;
|
|
}
|
|
|
|
write_kbs = (uint32_t)(((uint64_t)APP_TEST_EEPROM_SPEED_SIZE * (uint64_t)loops * 1000ULL) / (write_ms * 1024ULL));
|
|
read_kbs = (uint32_t)(((uint64_t)APP_TEST_EEPROM_SPEED_SIZE * (uint64_t)loops * 1000ULL) / (read_ms * 1024ULL));
|
|
|
|
APP_TEST_LOG("[APP_TEST] eeprom speed result: write=%llums(%luKB/s) read=%llums(%luKB/s)\r\n",
|
|
(unsigned long long)write_ms,
|
|
(unsigned long)write_kbs,
|
|
(unsigned long long)read_ms,
|
|
(unsigned long)read_kbs);
|
|
eeprom_buffer_write(bk, addr, (uint16_t)APP_TEST_EEPROM_SPEED_SIZE);
|
|
return 1U;
|
|
}
|
|
|
|
#define APP_TEST_CAN_TX_PERIOD_MS (1000ULL)
|
|
#define APP_TEST_CAN_EXT_ID_BASE (0x18FEE000U)
|
|
|
|
/* ================= USART 单路测试（可改参数） =================
|
|
* 简化版：每次执行 UART step 时
|
|
* - 发送一次（固定数据，可改）
|
|
* - 接收一次并打印（如有数据）
|
|
* 每次仅测试一个串口。
|
|
*/
|
|
static E_USART_ID s_uart_test_port = E_USART_3; /* 可改：E_USART_0/2/3/4/5/6/7 */
|
|
static uint8_t s_uart_test_tx_data[16] = { 0x55U, 0xAAU, 0x00U, 0x01U, 0x02U, 0x03U, 0x04U, 0x05U };
|
|
static uint16_t s_uart_test_tx_len = 8U;
|
|
|
|
static void v_app_test_uart_poll(void)
|
|
{
|
|
uint8_t rx_buf[128];
|
|
uint16_t rx_len;
|
|
uint16_t send_len = s_uart_test_tx_len;
|
|
|
|
if (send_len > (uint16_t)sizeof(s_uart_test_tx_data)) {
|
|
send_len = (uint16_t)sizeof(s_uart_test_tx_data);
|
|
}
|
|
|
|
if (send_len > 0U) {
|
|
(void)u16_usart_send(s_uart_test_port, s_uart_test_tx_data, send_len);
|
|
APP_TEST_LOG("[APP_TEST] uart tx port=%u len=%u\r\n",
|
|
(unsigned int)s_uart_test_port,
|
|
(unsigned int)send_len);
|
|
}
|
|
|
|
rx_len = u16_usart_recv(s_uart_test_port, rx_buf, (uint16_t)sizeof(rx_buf));
|
|
if (rx_len > 0U) {
|
|
char hex[3U * sizeof(rx_buf) + 4U];
|
|
uint32_t pos = 0U;
|
|
uint16_t i;
|
|
|
|
hex[0] = '\0';
|
|
for (i = 0U; i < rx_len && pos + 3U < sizeof(hex); i++) {
|
|
(void)snprintf(&hex[pos], sizeof(hex) - pos, "%02X ", (unsigned int)rx_buf[i]);
|
|
pos = (uint32_t)strlen(hex);
|
|
}
|
|
APP_TEST_LOG("[APP_TEST] uart rx port=%u len=%u %s\r\n",
|
|
(unsigned int)s_uart_test_port,
|
|
(unsigned int)rx_len,
|
|
hex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief 读空三路 CAN 软件缓存并打印（扩展帧由驱动层标记）。
|
|
*/
|
|
static void v_app_test_can_rx_drain(void)
|
|
{
|
|
uint8_t port;
|
|
CAN_DATA rx[CAN_RX_BUFFER_SIZE];
|
|
uint8_t rx_cnt;
|
|
uint8_t i;
|
|
uint8_t k;
|
|
|
|
for (port = 0U; port < 3U; port++) {
|
|
rx_cnt = u8_can_rx((E_CAN_ID)port, &rx[0]);
|
|
for (k = 0U; k < rx_cnt; k++) {
|
|
char hex[3U * 8U + 4U] = {0};
|
|
uint32_t pos = 0U;
|
|
|
|
for (i = 0U; i < rx[k].Len && i < 8U && pos + 3U < sizeof(hex); i++) {
|
|
(void)snprintf(&hex[pos], sizeof(hex) - pos, "%02X ", (unsigned int)rx[k].Data[i]);
|
|
pos = (uint32_t)strlen(hex);
|
|
}
|
|
APP_TEST_LOG("[APP_TEST] can rx port=%u id=0x%08lX dlc=%u %s\r\n",
|
|
(unsigned int)port, (unsigned long)rx[k].ID, (unsigned int)rx[k].Len, hex);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief 三路 CAN 各发一帧扩展数据帧（8 字节，前 4 字节为递增序号）。
|
|
*/
|
|
static void v_app_test_can_tx_all_ports(uint32_t seq)
|
|
{
|
|
uint8_t port;
|
|
CAN_DATA tx;
|
|
|
|
for (port = 0U; port < 3U; port++) {
|
|
(void)memset(&tx, 0, sizeof(tx));
|
|
tx.ID = APP_TEST_CAN_EXT_ID_BASE + (uint32_t)port;
|
|
tx.Len = 8U;
|
|
tx.Data[0] = (uint8_t)(seq & 0xFFU);
|
|
tx.Data[1] = (uint8_t)((seq >> 8) & 0xFFU);
|
|
tx.Data[2] = (uint8_t)((seq >> 16) & 0xFFU);
|
|
tx.Data[3] = (uint8_t)((seq >> 24) & 0xFFU);
|
|
tx.Data[4] = port;
|
|
tx.Data[5] = 0xC0U;
|
|
tx.Data[6] = 0xAAU;
|
|
tx.Data[7] = 0x55U;
|
|
v_can_tx((E_CAN_ID)port, &tx);
|
|
}
|
|
APP_TEST_LOG("[APP_TEST] can tx 3ch ext seq=%lu base_id=0x%08lX\r\n",
|
|
(unsigned long)seq, (unsigned long)APP_TEST_CAN_EXT_ID_BASE);
|
|
}
|
|
|
|
/**
|
|
* @brief CAN 周期任务：每 1s 三路各发一帧扩展帧；每次调用先收完并打印。
|
|
* @note 挂在 v_app_test_periodic 入口，随 MyLog 任务节拍轮询（不受 10s 自检节流影响）。
|
|
*/
|
|
static void v_app_test_can_poll(void)
|
|
{
|
|
static uint64_t s_next_tx_ms = 0ULL;
|
|
static uint32_t s_tx_seq = 0U;
|
|
uint64_t now_ms;
|
|
|
|
v_app_test_can_rx_drain();
|
|
|
|
if (u8_can_is_initialized() == 0U) {
|
|
v_can_interface_init();
|
|
}
|
|
|
|
now_ms = u64_get_current_millis();
|
|
if (s_next_tx_ms == 0ULL) {
|
|
s_next_tx_ms = now_ms;
|
|
}
|
|
if (now_ms < s_next_tx_ms) {
|
|
return;
|
|
}
|
|
|
|
s_next_tx_ms = now_ms + APP_TEST_CAN_TX_PERIOD_MS;
|
|
v_app_test_can_tx_all_ports(s_tx_seq);
|
|
s_tx_seq++;
|
|
}
|
|
|
|
/**
|
|
* @brief 通过 u8_get_yxyc_data 读取整桩/枪实时采集结构并打印（与 collect_task 内数据源一致）。
|
|
*/
|
|
static void v_app_test_collect_yxyc_snapshot_print(void)
|
|
{
|
|
SYS_RT_DATA pile;
|
|
GUN_RT_DATA gun;
|
|
U8_T gun_cnt;
|
|
U8_T i;
|
|
|
|
if (u8_get_yxyc_data(&pile, NULL, 0U) == 0U) {
|
|
APP_TEST_LOG("[APP_TEST] coll get sys fail (lock/busy)\r\n");
|
|
return;
|
|
}
|
|
APP_TEST_LOG("[APP_TEST] ****************************************************** start ******************************************************\r\n");
|
|
APP_TEST_LOG("[APP_TEST] coll SYS yx_raw=0x%08lX\r\n",
|
|
(unsigned long)pile.yx_sys_data.u32_yx_sys_data);
|
|
APP_TEST_LOG("[APP_TEST] SYS_yx estp=%u door=%u water=%u smoke=%u busKM=%u spd=%u acKM=%u qf=%u\r\n",
|
|
(unsigned int)pile.yx_sys_data.bit_yx_sys_data.yx_emergency,
|
|
(unsigned int)pile.yx_sys_data.bit_yx_sys_data.yx_door,
|
|
(unsigned int)pile.yx_sys_data.bit_yx_sys_data.yx_water,
|
|
(unsigned int)pile.yx_sys_data.bit_yx_sys_data.yx_smoke,
|
|
(unsigned int)pile.yx_sys_data.bit_yx_sys_data.yx_bus_KM,
|
|
(unsigned int)pile.yx_sys_data.bit_yx_sys_data.yx_spd,
|
|
(unsigned int)pile.yx_sys_data.bit_yx_sys_data.yx_KM,
|
|
(unsigned int)pile.yx_sys_data.bit_yx_sys_data.yx_QF);
|
|
APP_TEST_LOG("[APP_TEST] SYS_yc temp1_x1000=%ld temp2_x1000=%ld\r\n",
|
|
(long)(pile.f32_yc_sys_temp1 * 1000.0f),
|
|
(long)(pile.f32_yc_sys_temp2 * 1000.0f));
|
|
|
|
APP_TEST_LOG("[APP_TEST] hw_DOgpio(1=H 0=L) K1-K5 : %u %u %u %u %u\r\n",
|
|
(unsigned int)DO1_READ(), (unsigned int)DO2_READ(), (unsigned int)DO3_READ(),
|
|
(unsigned int)DO4_READ(), (unsigned int)DO5_READ());
|
|
APP_TEST_LOG("[APP_TEST] hw_DOgpio(1=H 0=L) K6-K10: %u %u %u %u %u | ELOCK_A=%u ELOCK_B=%u\r\n",
|
|
(unsigned int)DO6_READ(), (unsigned int)DO7_READ(), (unsigned int)DO8_READ(),
|
|
(unsigned int)DO9_READ(), (unsigned int)DO10_READ(),
|
|
(unsigned int)ELOCK_A_READ(), (unsigned int)ELOCK_B_READ());
|
|
|
|
gun_cnt = (U8_T)GUN_MAX_CNT;
|
|
|
|
for (i = 0U; i < gun_cnt; i++) {
|
|
if (u8_get_yxyc_data(NULL, &gun, i) == 0U) {
|
|
APP_TEST_LOG("[APP_TEST] coll get gun%u fail\r\n", (unsigned int)i);
|
|
continue;
|
|
}
|
|
APP_TEST_LOG("[APP_TEST] coll GUN%u link=%u\r\n",
|
|
(unsigned int)i,
|
|
(unsigned int)gun.u8_gunlink_state);
|
|
APP_TEST_LOG("[APP_TEST] GUN_yx raw=0x%08lX lock=%u dcP=%u dcN=%u rlf=%u fuse=%u apw=%u home=%u\r\n",
|
|
(unsigned long)gun.yx_gun_data.u32_yx_gun_data,
|
|
(unsigned int)gun.yx_gun_data.bit_yx_gun_data.yx_gun_lock,
|
|
(unsigned int)gun.yx_gun_data.bit_yx_gun_data.yx_switch_pos,
|
|
(unsigned int)gun.yx_gun_data.bit_yx_gun_data.yx_switch_neg,
|
|
(unsigned int)gun.yx_gun_data.bit_yx_gun_data.yx_relief_swich,
|
|
(unsigned int)gun.yx_gun_data.bit_yx_gun_data.yx_fuse,
|
|
(unsigned int)gun.yx_gun_data.bit_yx_gun_data.yx_gun_power,
|
|
(unsigned int)gun.yx_gun_data.bit_yx_gun_data.yx_gun_homing);
|
|
APP_TEST_LOG("[APP_TEST] GUN_yc bus_mV V+=%ld V-=%ld I_mA=%ld\r\n",
|
|
(long)(gun.f32_yc_gun_vol_pos * 1000.0f),
|
|
(long)(gun.f32_yc_gun_vol_neg * 1000.0f),
|
|
(long)(gun.f32_yc_gun_curr * 1000.0f));
|
|
APP_TEST_LOG("[APP_TEST] GUN_yc bat_mV V+=%ld V-=%ld | gunTemp_x1000 Tpos=%ld Tneg=%ld\r\n",
|
|
(long)(gun.f32_yc_bat_vol_pos * 1000.0f),
|
|
(long)(gun.f32_yc_bat_vol_neg * 1000.0f),
|
|
(long)(gun.f32_yc_gun_temp_pos * 1000.0f),
|
|
(long)(gun.f32_yc_gun_temp_neg * 1000.0f));
|
|
}
|
|
APP_TEST_LOG("[APP_TEST] ****************************************************** end ******************************************************\r\n");
|
|
|
|
}
|
|
|
|
/**
|
|
* @brief 对外：以 1MB 步长扫描 32MB 地址空间读写校验。
|
|
* @details
|
|
* - 每个步长点执行：扇区擦除 -> 写入 1KB 模式数据 -> 读回校验；
|
|
* - 任一点失败立即返回并打印失败地址；
|
|
* - 全部通过后打印总耗时。
|
|
* @return 1 通过，0 失败。
|
|
*/
|
|
uint8_t u8_app_test_flash_32m_stride_rw(void)
|
|
{
|
|
uint32_t addr;
|
|
uint32_t i;
|
|
uint32_t seed;
|
|
uint64_t t0;
|
|
uint64_t t1;
|
|
uint64_t elapsed_ms;
|
|
uint8_t *tx_raw;
|
|
uint8_t *rx_raw;
|
|
uint8_t *tx_buf;
|
|
uint8_t *rx_buf;
|
|
|
|
if (app_test_alloc_aligned_buffers(&tx_raw, &rx_raw, &tx_buf, &rx_buf) == 0U) {
|
|
APP_TEST_LOG("[APP_TEST] 32M stride malloc fail\r\n");
|
|
return 0U;
|
|
}
|
|
|
|
APP_TEST_LOG("[APP_TEST] 32M stride test start, step=0x%08X, size=%u\r\n",
|
|
(unsigned int)APP_TEST_FLASH_STEP_1M,
|
|
(unsigned int)APP_TEST_FLASH_RW_SIZE);
|
|
|
|
t0 = u64_get_current_millis();
|
|
for (addr = 0U; addr < APP_TEST_FLASH_TOTAL_32M; addr += APP_TEST_FLASH_STEP_1M) {
|
|
seed = (uint32_t)(addr ^ 0x5A5A0000U);
|
|
for (i = 0U; i < APP_TEST_FLASH_RW_SIZE; i++) {
|
|
tx_buf[i] = (uint8_t)((seed + i) & 0xFFU);
|
|
}
|
|
(void)memset(rx_buf, 0, APP_TEST_FLASH_RW_SIZE);
|
|
|
|
(void)s32_flash_dataflash_erase_sector(addr);
|
|
(void)s32_flash_dataflash_write(addr, tx_buf, APP_TEST_FLASH_RW_SIZE);
|
|
(void)s32_flash_dataflash_read(addr, rx_buf, APP_TEST_FLASH_RW_SIZE);
|
|
|
|
if (memcmp(tx_buf, rx_buf, APP_TEST_FLASH_RW_SIZE) != 0) {
|
|
APP_TEST_LOG("[APP_TEST] 32M stride verify fail, addr=0x%08lX, seed=0x%08lX\r\n",
|
|
(unsigned long)addr,
|
|
(unsigned long)seed);
|
|
app_test_free_aligned_buffers(tx_raw, rx_raw);
|
|
return 0U;
|
|
}
|
|
}
|
|
t1 = u64_get_current_millis();
|
|
elapsed_ms = t1 - t0;
|
|
|
|
APP_TEST_LOG("[APP_TEST] 32M stride test pass, range=0x00000000~0x01FFFFFF, elapsed=%llums\r\n", elapsed_ms);
|
|
|
|
app_test_free_aligned_buffers(tx_raw, rx_raw);
|
|
return 1U;
|
|
}
|
|
|
|
/**
|
|
* @brief 周期触发综合测试（RTC/EEPROM/Flash）。
|
|
* @details 首次调用仅记录起始时间，不立即执行测试。
|
|
*/
|
|
void v_app_test_periodic(void)
|
|
{
|
|
static uint32_t s_last_test_sec = 0U;
|
|
static uint8_t s_test_step = (uint8_t)APP_TEST_STEP_RTC;
|
|
uint32_t now_sec;
|
|
|
|
if (s_last_test_sec == 0U) {
|
|
s_last_test_sec = get_current_seconds();
|
|
return;
|
|
}
|
|
|
|
now_sec = get_current_seconds();
|
|
/* 改为 1 秒节拍执行一次 step（按你的要求）。 */
|
|
if (u32_safe_seconds_since(s_last_test_sec) < 1U) {
|
|
return;
|
|
}
|
|
|
|
// APP_TEST_LOG("[APP_TEST] app test periodic\r\n");
|
|
/* 改用“数字递增 step”的方式，避免 bitmask 维护成本。 */
|
|
switch ((APP_TEST_STEP_T)s_test_step) {
|
|
case APP_TEST_STEP_RTC:
|
|
// v_app_test_rtc_rw_once();
|
|
test_rtc(); //测试RTC
|
|
s_test_step++;
|
|
break;
|
|
case APP_TEST_STEP_EEPROM_BASIC:
|
|
// (void)u8_app_test_eeprom_rw_once();
|
|
s_test_step++;
|
|
break;
|
|
case APP_TEST_STEP_EEPROM_MULTI:
|
|
// (void)u8_app_test_eeprom_multi_addr_rw_once();
|
|
s_test_step++;
|
|
break;
|
|
case APP_TEST_STEP_EEPROM_SPEED:
|
|
// (void)u8_app_test_eeprom_speed_once();
|
|
s_test_step++;
|
|
break;
|
|
case APP_TEST_STEP_CAN:
|
|
/* 每秒发送一次 + 周期接收打印（函数内部有 1s 节拍控制）。 */
|
|
// v_app_test_can_poll();
|
|
s_test_step++;
|
|
break;
|
|
case APP_TEST_STEP_UART:
|
|
// v_app_test_uart_poll();
|
|
v_app_test_collect_yxyc_snapshot_print();
|
|
s_test_step++;
|
|
break;
|
|
#if (APP_TEST_ENABLE_FLASH_SPEED)
|
|
case APP_TEST_STEP_FLASH_SPEED:
|
|
// v_app_test_flash_rw_speed_once();
|
|
s_test_step++;
|
|
break;
|
|
#endif
|
|
case APP_TEST_STEP_FLASH_STRIDE:
|
|
// if (u8_app_test_flash_32m_stride_rw() == 0U) {
|
|
// APP_TEST_LOG("[APP_TEST] 32M stride test failed in periodic flow\r\n");
|
|
// }
|
|
s_test_step++;
|
|
break;
|
|
case APP_TEST_STEP_DONE:
|
|
s_test_step = (uint8_t)APP_TEST_STEP_RTC;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
s_last_test_sec = now_sec;
|
|
}
|
|
|
|
#else
|
|
|
|
void v_app_test_periodic(void)
|
|
{
|
|
/* test disabled by APP_TEST_ENABLE */
|
|
}
|
|
|
|
#endif /* APP_TEST_ENABLE */
|