wangyan/CCU621M
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: CCU621_M firmware project with BLE debug link support.

Browse Source 
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
jiankalka
2026-07-08 17:28:36 +08:00
commit 9ceb218f80
1597 changed files with 724159 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/app_init/app_test.c
+905
View File
@@ -0,0 +1,905 @@
#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 */