zouhaitao/TAIXIN
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: TXW82x FPV v2.7.0.7-42229 SDK + project sources

Browse Source
This commit is contained in:
zouhaitao
2026-07-06 11:30:13 +08:00
commit e76462eeb7
3451 changed files with 1415300 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
sdk/app/debug_log_msi/debug_log_msi.c Normal file
View File

@@ -0,0 +1,285 @@
// 主要是增加debug流,可以保存log到内存,然后发向流,可以作为定时保存log使用
// 这个流就不作保护,所以最好单线程去使用(如果多线程,可以增加锁),可以使用一个
// 全局去保存对应的句柄,但是这里就不全局保存也不使用全局(可以创建多个流,每个
// 独立的线程可以独立调试)
#include "debug_log_msi.h"
#define DEBUG_LOG_STREAM_MALLOC av_psram_malloc
#define DEBUG_LOG_STREAM_FREE av_psram_free
// 结构体申请空间函数
#define STREAM_LIBC_MALLOC av_malloc
#define STREAM_LIBC_FREE av_free
#define STREAM_LIBC_ZALLOC av_zalloc
#define DEBUG_LOG_MAX_NUM 10
#define DEBUG_LOG_CACHE_SIZE (1024 * 4) // 4K
#define DBG_LOG_FAIL_TIMES (3)
static int32_t debug_log_action(struct msi *msi, uint32_t cmd_id, uint32_t param1, uint32_t param2)
{
int32_t ret = RET_OK;
struct dbg_log_s *log_s = (struct dbg_log_s *) msi->priv;
switch (cmd_id)
{
case MSI_CMD_POST_DESTROY:
{
fbpool_destroy(&log_s->tx_pool);
if (log_s)
{
STREAM_LIBC_FREE(log_s);
msi->priv = NULL;
}
}
break;
case MSI_CMD_PRE_DESTROY:
{
if (log_s)
{
os_work_cancle2(&log_s->work, 1);
}
}
break;
case MSI_CMD_FREE_FB:
{
struct framebuff *fb = (struct framebuff *) param1;
if (fb->data)
{
DEBUG_LOG_STREAM_FREE(fb->data);
fb->data = NULL;
}
fb->rev = 0;
fbpool_put(&log_s->tx_pool, fb);
// 不需要内核去释放fb
ret = RET_OK + 1;
}
break;
}
return ret;
}
static uint32_t sync_debug_buf(struct dbg_log_s *log_s)
{
uint32_t flags;
int ret = 0;
struct framebuff *fb = NULL;
flags = disable_irq();
if (log_s->fb && log_s->offset)
{
fb = log_s->fb;
fb->len = log_s->offset;
log_s->fb = NULL;
log_s->offset = 0;
}
enable_irq(flags);
if (fb)
{
ret = fb->len;
msi_output_fb(log_s->s, fb);
}
return ret;
}
static int32 debug_log_sync_work(struct os_work *work)
{
struct dbg_log_s *log_s = (struct dbg_log_s *) work;
sync_debug_buf(log_s);
os_run_work_delay(work, 1000);
return 0;
}
void *dbg_log_msi(const char *host_name)
{
struct msi *s = NULL;
uint8_t isnew;
struct dbg_log_s *log_s;
s = msi_new(host_name, 0, &isnew);
if (isnew)
{
log_s = (struct dbg_log_s *) STREAM_LIBC_ZALLOC(sizeof(struct dbg_log_s));
ASSERT(log_s);
s->priv = (void *) log_s;
s->action = (msi_action) debug_log_action;
fbpool_init(&log_s->tx_pool, DEBUG_LOG_MAX_NUM);
log_s->s = s;
log_s->fb = NULL;
log_s->offset = 0;
OS_WORK_INIT(&log_s->work, debug_log_sync_work, 0);
os_run_work_delay(&log_s->work, 1000);
msi_add_output(s, NULL, R_DEBUG_STREAM);
s->enable = 1;
}
return s;
}
uint8_t *get_debug_buf(struct dbg_log_s *log_s, uint32_t *write_len, uint32_t len)
{
uint8_t *malloc_buf;
uint8_t *buf;
uint32_t remain_size;
uint32_t flags;
uint8_t disable_irq_en = 0;
uint32_t times = 0;
struct framebuff *fb = NULL;
again:
flags = disable_irq();
if (log_s->fb && (DEBUG_LOG_CACHE_SIZE == log_s->offset))
{
fb = log_s->fb;
fb->len = log_s->offset;
log_s->fb = NULL;
log_s->offset = 0;
}
enable_irq(flags);
if (fb)
{
msi_output_fb(log_s->s, fb);
}
if (!log_s->fb)
{
malloc_buf = (uint8_t *) DEBUG_LOG_STREAM_MALLOC(DEBUG_LOG_CACHE_SIZE);
if (malloc_buf)
{
flags = disable_irq();
disable_irq_en = 1;
if (!log_s->fb)
{
log_s->fb = fbpool_get(&log_s->tx_pool, 0, log_s->s);
if (log_s->fb)
{
log_s->fb->data = malloc_buf;
log_s->offset = 0;
}
}
else
{
DEBUG_LOG_STREAM_FREE(malloc_buf);
}
}
}
// 如果没有关闭中断,就关闭中断去操?因为log_s->fb有可能需要同步,会被释放
if (!disable_irq_en)
{
flags = disable_irq();
disable_irq_en = 1;
}
if (log_s->fb)
{
buf = log_s->fb->data + log_s->offset;
remain_size = DEBUG_LOG_CACHE_SIZE - log_s->offset;
if (remain_size > len)
{
*write_len = len;
}
else
{
*write_len = remain_size;
}
log_s->offset += (*write_len);
}
else
{
*write_len = 0;
buf = NULL;
}
if (disable_irq_en)
{
enable_irq(flags);
}
times++;
// 如果保存失败,重新去尝试吧
if (!buf && (times < DBG_LOG_FAIL_TIMES))
{
os_sleep_ms(1);
goto again;
}
return buf;
}
uint8_t *get_debug_buf_interrupt(struct dbg_log_s *log_s, uint32_t *write_len, uint32_t len)
{
uint8_t *buf;
uint32_t remain_size;
//uint32_t flags;
if (log_s->fb)
{
buf = log_s->fb->data + log_s->offset;
remain_size = DEBUG_LOG_CACHE_SIZE - log_s->offset;
if (remain_size >= len)
{
*write_len = len;
}
else
{
*write_len = remain_size;
log_s->fb->rev = 1; // 标记有数据漏了,log那里可以记录一下
}
if (!remain_size)
{
*write_len = 0;
buf = NULL;
}
log_s->offset += (*write_len);
}
else
{
*write_len = 0;
buf = NULL;
}
return buf;
}
void hgprntf_debug_log_msi(void *priv, char *str, int32 len)
{
uint32_t in_disable_irq(void);
uint8_t *buf;
struct dbg_log_s *log_s = (struct dbg_log_s *) priv;
if (__in_interrupt() || in_disable_irq())
{
uint32_t cp_len;
if (len == 0)
{
len = os_strlen(str);
}
buf = get_debug_buf_interrupt(log_s, &cp_len, len);
if (buf)
{
os_memcpy(buf, str, cp_len);
len -= cp_len;
str += cp_len;
}
return;
}
if (len == 0)
{
len = os_strlen(str);
}
do
{
uint32_t cp_len;
buf = get_debug_buf(log_s, &cp_len, len);
if (buf)
{
os_memcpy(buf, str, cp_len);
len -= cp_len;
str += cp_len;
}
} while (len && buf);
}

20
sdk/app/debug_log_msi/debug_log_msi.h Normal file
View File

@@ -0,0 +1,20 @@
#ifndef __DEBUG_LOG_STREAM_H
#define __DEBUG_LOG_STREAM_H
#include "basic_include.h"
#include "lib/multimedia/msi.h"
#include "lib/heap/av_heap.h"
#include "lib/heap/av_psram_heap.h"
#include "stream_frame.h"
struct dbg_log_s
{
struct os_work work;
struct msi *s;
struct framebuff *fb; //当前的data_s
struct fbpool tx_pool;
uint32_t offset; //当前数据的偏移,最大值是cache_data_size
};
void hgprntf_debug_log_msi(void *priv, char *str, int32 len);
void *dbg_log_msi(const char *host_name);
#endif

292
sdk/app/debug_log_msi/log_save_msi.c Normal file
View File

@@ -0,0 +1,292 @@
#include "log_save_msi.h"
// 接收debug_stream的log保存到sd卡
#define LOG_MALLOC av_psram_malloc
#define LOG_FREE av_psram_free
#define LOG_SIZE_UINT (100 * 1024)
#define SAVE_RESERVE_SIZE (10 + 1 + 8 + 1)
#define SAVE_FLAG_FORMAT "[%08d]:log end\n"
#define WRITE_DROP_DATA_FLAG "[%08d]:interrupt drop\n"
#define LOG_SAVE_PATH "0:log"
static int32 log_save_work(struct os_work *work)
{
struct log_save_s *log_s = (struct log_save_s *) work;
struct framebuff *get_f;
struct msi *s = log_s->s;
uint32_t tell = 0;
char filename[64];
int ret = 0;
// 尝试接收数据,看看是否有需要写入到sd卡或者缓冲区buf
get_f = msi_get_fb(s, 0);
if (get_f && get_f->rev != 0)
{
log_s->drop_data_flag = 1;
}
if (get_f)
{
uint32_t write_cache_size = get_f->len;
// 要先判断缓冲区是否足够空间,如果不够,则先将缓冲区写入到sd卡,然后再将数据拷贝到缓冲区
if (log_s->start_offset + log_s->offset + write_cache_size + SAVE_RESERVE_SIZE > CACHE_SIZE)
{
// 将当前缓冲区写入sd卡,然后再将数据拷贝到缓冲区
if (!log_s->fp)
{
struct tm *time_info;
struct timeval ptimeval;
gettimeofday(&ptimeval, NULL);
time_t time_val = (time_t) ptimeval.tv_sec;
time_info = gmtime(&time_val);
uint32_t year = time_info->tm_year + 1900;
uint32_t mon = time_info->tm_mon + 1;
uint32_t day = time_info->tm_mday;
uint32_t hour = time_info->tm_hour;
uint32_t min = time_info->tm_min;
uint32_t sec = time_info->tm_sec;
uint32_t ms = os_jiffies() % 1000;
os_sprintf((char *) filename, "%s/%04d%02d%02d%02d%02d%02d%03d.txt", LOG_SAVE_PATH, year, mon, day, hour, min, sec, ms);
log_s->fp = osal_fopen_auto((const char *) filename, "wb", 0);
log_s->filesize = 0;
if (log_s->fp)
{
log_s->filesize = LOG_SIZE_UINT;
tell = osal_ftell(log_s->fp);
// 预分配文件簇
osal_fseek(log_s->fp, log_s->filesize);
osal_fseek(log_s->fp, tell);
}
log_s->lastupdate_file_time = os_jiffies();
log_s->last_syn_time = os_jiffies();
}
if (log_s->fp)
{
tell = osal_ftell(log_s->fp);
if (log_s->filesize < tell + log_s->offset)
{
log_s->filesize += LOG_SIZE_UINT;
}
// 预分配文件簇
osal_fseek(log_s->fp, log_s->filesize);
osal_fseek(log_s->fp, tell);
// 如果有漏数据,则在这里写入一个特殊标志,代表曾经漏过数据,不保证漏数据多少,只是一个标志
if (log_s->drop_data_flag)
{
os_sprintf(filename, WRITE_DROP_DATA_FLAG, (uint32_t) os_jiffies());
osal_fwrite(filename, strlen(filename), 1, log_s->fp);
log_s->drop_data_flag = 0;
}
ret = osal_fwrite(log_s->save_buf + log_s->start_offset, log_s->offset + SAVE_RESERVE_SIZE, 1, log_s->fp);
tell = osal_ftell(log_s->fp);
osal_fseek(log_s->fp, tell - SAVE_RESERVE_SIZE);
if (!ret)
{
osal_ftruncate(log_s->fp);
osal_fclose(log_s->fp);
log_s->fp = NULL;
}
log_s->start_offset = 0;
log_s->offset = 0;
}
// 重新将获取到的数据保存到save_buf,可能要考虑没有sd卡的情况?
// 没有sd卡,直接丢弃?
// 理论这里offset一定是从0开始
if (log_s->fp)
{
// 判断当前位置,调整start_offset,作为对齐使用
uint32_t tell = osal_ftell(log_s->fp);
log_s->start_offset = 4 - tell % 4;
hw_memcpy(log_s->save_buf + log_s->start_offset + log_s->offset, get_f->data, write_cache_size);
os_sprintf((char *) log_s->save_buf + log_s->start_offset + log_s->offset + write_cache_size, SAVE_FLAG_FORMAT, osal_ftell(log_s->fp));
log_s->offset = write_cache_size;
}
}
// 缓冲区足够,直接拷贝
else
{
// 将当前缓冲区写入sd卡,然后再将数据拷贝到缓冲区
if (!log_s->fp)
{
struct tm *time_info;
struct timeval ptimeval;
gettimeofday(&ptimeval, NULL);
time_t time_val = (time_t) ptimeval.tv_sec;
time_info = gmtime(&time_val);
uint32_t year = time_info->tm_year + 1900;
uint32_t mon = time_info->tm_mon + 1;
uint32_t day = time_info->tm_mday;
uint32_t hour = time_info->tm_hour;
uint32_t min = time_info->tm_min;
uint32_t sec = time_info->tm_sec;
uint32_t ms = os_jiffies() % 1000;
os_sprintf((char *) filename, "%s/%04d%02d%02d%02d%02d%02d%03d.txt", LOG_SAVE_PATH, year, mon, day, hour, min, sec, ms);
log_s->fp = osal_fopen_auto((const char *) filename, "wb", 0);
log_s->filesize = 0;
log_s->lastupdate_file_time = os_jiffies();
log_s->last_syn_time = os_jiffies();
}
if (log_s->fp)
{
hw_memcpy(log_s->save_buf + log_s->start_offset + log_s->offset, get_f->data, write_cache_size);
os_sprintf((char *) log_s->save_buf + log_s->start_offset + log_s->offset + write_cache_size, SAVE_FLAG_FORMAT, osal_ftell(log_s->fp) + log_s->offset + write_cache_size);
log_s->offset += write_cache_size;
}
}
msi_delete_fb(NULL, get_f);
}
// 如果存在文件,要判断是否需要更换文件保存log
if (log_s->fp && (os_jiffies() - log_s->lastupdate_file_time > log_s->update_file_interval))
{
if (log_s->offset)
{
// 如果有漏数据,则在这里写入一个特殊标志,代表曾经漏过数据,不保证漏数据多少,只是一个标志
if (log_s->drop_data_flag)
{
os_sprintf(filename, WRITE_DROP_DATA_FLAG, (uint32_t) os_jiffies());
osal_fwrite(filename, strlen(filename), 1, log_s->fp);
log_s->drop_data_flag = 0;
}
osal_fwrite(log_s->save_buf + log_s->start_offset, log_s->offset, 1, log_s->fp);
}
log_s->last_syn_time = os_jiffies();
log_s->lastupdate_file_time = os_jiffies();
osal_ftruncate(log_s->fp);
osal_fclose(log_s->fp);
log_s->fp = NULL;
log_s->start_offset = 0;
log_s->offset = 0;
}
// 先判断是否要切换下一个文件去记录log
// 去同步一下
if (os_jiffies() - log_s->last_syn_time > log_s->syn_interval)
{
if (log_s->fp)
{
if (log_s->offset)
{
if (log_s->fp)
{
tell = osal_ftell(log_s->fp);
if (log_s->filesize < tell + log_s->offset)
{
log_s->filesize += LOG_SIZE_UINT;
}
// 预分配文件簇
osal_fseek(log_s->fp, log_s->filesize);
osal_fseek(log_s->fp, tell);
}
// 如果有漏数据,则在这里写入一个特殊标志,代表曾经漏过数据,不保证漏数据多少,只是一个标志
if (log_s->drop_data_flag)
{
os_sprintf(filename, WRITE_DROP_DATA_FLAG, (uint32_t) os_jiffies());
osal_fwrite(filename, strlen(filename), 1, log_s->fp);
log_s->drop_data_flag = 0;
}
ret = osal_fwrite(log_s->save_buf + log_s->start_offset, log_s->offset + SAVE_RESERVE_SIZE, 1, log_s->fp);
tell = osal_ftell(log_s->fp);
osal_fseek(log_s->fp, tell - SAVE_RESERVE_SIZE);
tell = osal_ftell(log_s->fp);
if (!ret)
{
osal_ftruncate(log_s->fp);
osal_fclose(log_s->fp);
log_s->fp = NULL;
goto __log_save_work_end;
}
log_s->start_offset = 0;
log_s->offset = 0;
}
osal_fsync(log_s->fp);
}
else
{
log_s->start_offset = 0;
log_s->offset = 0;
}
log_s->last_syn_time = os_jiffies();
}
__log_save_work_end:
os_run_work_delay(work, 1);
return 0;
}
static int32_t log_save_action(struct msi *msi, uint32_t cmd_id, uint32_t param1, uint32_t param2)
{
int32_t ret = RET_OK;
struct log_save_s *log_s = (struct log_save_s *) msi->priv;
switch (cmd_id)
{
case MSI_CMD_POST_DESTROY:
{
if (log_s->fp)
{
osal_ftruncate(log_s->fp);
osal_fclose(log_s->fp);
}
if (log_s)
{
LOG_FREE(log_s);
msi->priv = NULL;
}
}
break;
case MSI_CMD_PRE_DESTROY:
{
os_work_cancle2(&log_s->work, 1);
}
break;
case MSI_CMD_FREE_FB:
{
}
break;
}
return ret;
}
void *creat_log_save_stream(const char *name, uint32_t syn_interval, uint32_t update_file_interval)
{
struct log_save_s *log_s = (struct log_save_s *) LOG_MALLOC(sizeof(struct log_save_s));
struct msi *s = NULL;
if (log_s)
{
memset(log_s, 0, sizeof(struct log_save_s));
log_s->syn_interval = syn_interval;
log_s->update_file_interval = update_file_interval;
s = msi_new(name, 10, NULL);
if (s)
{
s->action = log_save_action;
s->priv = (void *) log_s;
s->enable = 1;
log_s->s = s;
OS_WORK_INIT(&log_s->work, log_save_work, 0);
os_run_work_delay(&log_s->work, 1);
}
else
{
LOG_FREE(log_s);
log_s = NULL;
}
}
return s;
}

32
sdk/app/debug_log_msi/log_save_msi.h Normal file
View File

@@ -0,0 +1,32 @@
#ifndef __LOG_SAVE_STREAM_H
#define __LOG_SAVE_STREAM_H
#include "basic_include.h"
#include "lib/multimedia/msi.h"
#include "lib/heap/av_heap.h"
#include "lib/heap/av_psram_heap.h"
#include "stream_frame.h"
#include "osal_file.h"
#define CACHE_SIZE (4096)
struct log_save_s
{
struct os_work work;
struct msi *s;
uint32_t save_len;
uint8_t save_buf[CACHE_SIZE + 64]; // 设置一个缓冲区,暂时是4K
uint16_t offset; // 这个只会小于等于CACHE_SIZE
uint16_t start_offset; // 因为写入sd存在可能不对齐的问题,所以这里会有一个基础偏移来作为对齐
uint32_t last_syn_time; // 上一次同步的时间
uint32_t lastupdate_file_time; // 上一次更换文件的时间
uint32_t update_file_interval; // 定时切换log文件,尽量保证旧文件是完整的
uint32_t filesize;
uint16_t syn_interval; // 同步间隔
uint8_t drop_data_flag; // 是否需要写入interrupt drop标志
void *fp;
};
void *creat_log_save_stream(const char *name, uint32_t syn_interval, uint32_t update_file_interval);
#endif