LiuYuanchi
/
phytium-vsipl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

inti2

This commit is contained in:
liuyuanchi 2024-05-21 16:46:33 +08:00
parent b9143a8db3
commit 795bc5f731
12 changed files with 259 additions and 326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -6,3 +6,4 @@ radar
*.o
*.a
*.so
data

2
Makefile
View File

@ -28,4 +28,4 @@ run: $(TARGET)s
clean:
rm -f $(TARGET) $(OBJ)
rm -rf data obj
rm -rf obj

4
README.md
View File

@ -302,7 +302,7 @@ void detect_signal(vsip_cvview_f *p_vector_signal, vsip_scalar_f f_threshold,
* p_file -- 输出文件
* 功能：将实向量的数据输出到文件
*/
void vdump_f(vsip_vview_f *p_vector, FILE *p_file);
void outputRealVector(vsip_vview_f *p_vector, FILE *p_file);
/*
* 内部接口：输出复向量
@ -310,7 +310,7 @@ void vdump_f(vsip_vview_f *p_vector, FILE *p_file);
* p_file -- 输出文件
* 功能：将复向量的数据输出到文件
*/
void cvdump_f(vsip_cvview_f *p_vector, FILE *p_file);
void outputComplexVector(vsip_cvview_f *p_vector, FILE *p_file);
/*
* 内部接口：实向量调试

23
include/tool.h Executable file
View File

@ -0,0 +1,23 @@
#ifndef RADAR_UTILS_H_
#define RADAR_UTILS_H_
#include "vsip.h"
/*
* 输出实向量
* 参数：p_vector -- 输入向量
* p_file -- 输出文件
* 功能：将实向量的数据输出到文件
*/
void outputRealVector(vsip_vview_f *p_vector, char *p_name);
/*
* 输出复向量
* 参数：p_vector -- 输入向量
* p_file -- 输出文件
* 功能：将复向量的数据输出到文件
*/
void outputComplexVector(vsip_cvview_f *p_vector,char *p_name);
#endif

54
include/utils.h
View File

@ -1,54 +0,0 @@
#ifndef RADAR_UTILS_H_
#define RADAR_UTILS_H_
#include "vsip.h"
/*
* 内部接口：输出实向量
* 参数：p_vector -- 输入向量
* p_file -- 输出文件
* 功能：将实向量的数据输出到文件
*/
void vdump_f(vsip_vview_f *p_vector, FILE *p_file);
/*
* 内部接口：输出复向量
* 参数：p_vector -- 输入向量
* p_file -- 输出文件
* 功能：将复向量的数据输出到文件
*/
void cvdump_f(vsip_cvview_f *p_vector, FILE *p_file);
/*
* 内部接口：实向量调试
* 参数：p_vector -- 输入向量
* p_name -- 输出文件名
* 功能：将实向量的数据输出到指定文件名的文件
*/
void vdebug_f(vsip_vview_f *p_vector, char *p_name);
/*
* 内部接口：复向量调试
* 参数：p_vector -- 输入向量
* p_name -- 输出文件名
* 功能：将复向量的数据输出到指定文件名的文件
*/
void cvdebug_f(vsip_cvview_f *p_vector, char *p_name);
/*
* 内部接口：复向量翻转
* 参数：p_vector_src -- 输入向量
* p_vector_dst -- 输出向量
* 功能：将输入向量的数据翻转后输出到输出向量
*/
void cvflip_f(vsip_cvview_f *p_vector_src, vsip_cvview_f *p_vector_dst);
/*
* 内部接口：复向量填充
* 参数：p_vector_src -- 输入向量
* p_vector_dst -- 输出向量
* 功能：根据输出向量的长度对输入向量进行零填充得到输出
*/
void cvpad_f(vsip_cvview_f *p_vector_src, vsip_cvview_f *p_vector_dst);
#endif

4
src/filter.c
View File

@ -1,5 +1,5 @@
#include "filter.h"
#include "utils.h"
#include "tool.h"
void hilbert(vsip_vview_f *p_vector_src, vsip_scalar_i n_filter_length, vsip_cvview_f *p_vector_dst)
{
@ -49,7 +49,7 @@ void hilbert(vsip_vview_f *p_vector_src, vsip_scalar_i n_filter_length, vsip_cvv
vsip_cvput_f(p_vector_hilbert_transformer, n_index, c_value);
}
cvdebug_f(p_vector_hilbert_transformer, "./data/hilbert_coefficients.txt");
outputComplexVector(p_vector_hilbert_transformer, "./data/hilbert_coefficients.txt");
// 得到滤波器系数的实部和虚部
vsip_vview_f *p_vector_hilbert_transformer_real =

6
src/hamming.c
View File

@ -7,14 +7,10 @@ void vcreate_hamming_f(vsip_vview_f *p_vector_dst)
fprintf(stderr, "vcreate_hamming_f: p_vector_dst is NULL\n");
return;
}
else
{
;
}
vsip_length n_length = vsip_vgetlength_f(p_vector_dst);
// 汉明窗有关参数
// 汉明窗参数
const vsip_scalar_f f_a0 = (float)0.53836;
const vsip_scalar_f f_a1 = (float)(1.0f - f_a0);

109
src/main.c
View File

@ -1,7 +1,7 @@
#include "filter.h"
#include "hamming.h"
#include "signal.h"
#include "utils.h"
#include "tool.h"
#include "vsip.h"
#include <stdio.h>
#include <stdlib.h>
@ -11,121 +11,110 @@ int main(int argc, char *argv[])
{
vsip_init((void *)0);
// 脉冲宽度
const vsip_scalar_f f_tau = 7e-6;
// 采样率
const vsip_scalar_f f_freq_sampling = 20e6;
// 下限频率
const vsip_scalar_f f_freq_low = 222e6;
// 带宽
const vsip_scalar_f f_band_width = 6e6;
// 目标距离
const vsip_scalar_f f_distance = 600.0f;
// LFM 信号长度
const vsip_length n_signal_length = (vsip_length)(0.5f + f_tau * f_freq_sampling);
// 延迟时间
const vsip_scalar_f f_delay_time = 2.0f * f_distance / 3e8;
// 总时间
const vsip_scalar_f f_total_time = f_tau + f_delay_time;
// 延迟信号长度（样本数量）
const vsip_length n_delay_signal_length = (vsip_length)(0.5f + f_delay_time * f_freq_sampling);
// 总信号长度（样本数量）
const vsip_length n_total_signal_length = (vsip_length)(0.5f + f_total_time * f_freq_sampling);
// 希尔伯特系数
const vsip_length n_hilbert_length = 11;
const vsip_scalar_f pulse_width = 7e-6; // 脉冲宽度
const vsip_scalar_f lower_limit_frequency = 222e6; // 下限频率
const vsip_scalar_f band_width = 6e6; // 带宽
const vsip_scalar_f sampling_rate = 20e6; // 采样率
const vsip_scalar_f distance = 600.0f; // 目标距离
const vsip_length signal_length = (vsip_length)(0.5f + pulse_width * sampling_rate); // LFM 信号长度
const vsip_scalar_f delay_time = 2.0f * distance / 3e8; // 延迟时间
const vsip_scalar_f total_time = pulse_width + delay_time; // 总时间
const vsip_length delay_signal_length = (vsip_length)(0.5f + delay_time * sampling_rate); // 延迟信号长度（样本数量）
const vsip_length total_signal_length = (vsip_length)(0.5f + total_time * sampling_rate); // 总信号长度（样本数量）
const vsip_length hilbert_length = 11; // 希尔伯特系数
// 生成雷达接收的实信号
vsip_vview_f *p_vector_radar_signal = vsip_vcreate_f(n_total_signal_length, VSIP_MEM_NONE);
generate_radar_signal(f_tau, f_freq_sampling, f_freq_low, f_band_width, 600.0f,
vsip_vview_f *p_vector_radar_signal = vsip_vcreate_f(total_signal_length, VSIP_MEM_NONE);
generate_radar_signal(pulse_width, sampling_rate, lower_limit_frequency, band_width, 600.0f,
p_vector_radar_signal);
// DEBUG
vdebug_f(p_vector_radar_signal, "./data/radar_signal.txt");
outputRealVector(p_vector_radar_signal, "./data/radar_signal.txt");
// 希尔伯特滤波
vsip_cvview_f *p_vector_radar_signal_filtered =
vsip_cvcreate_f(n_total_signal_length, VSIP_MEM_NONE);
vsip_cvcreate_f(total_signal_length, VSIP_MEM_NONE);
hilbert(p_vector_radar_signal, 11, p_vector_radar_signal_filtered);
// DEBUG
cvdebug_f(p_vector_radar_signal_filtered, "./data/radar_signal_filtered.txt");
outputComplexVector(p_vector_radar_signal_filtered, "./data/radar_signal_filtered.txt");
// 匹配滤波参考信号
vsip_cvview_f *p_vector_signal_ref = vsip_cvcreate_f(n_signal_length, VSIP_MEM_NONE);
generate_lfm_signal(f_tau, f_freq_sampling, f_freq_low, f_band_width, p_vector_signal_ref);
vsip_cvview_f *p_vector_signal_ref = vsip_cvcreate_f(signal_length, VSIP_MEM_NONE);
generate_lfm_signal(pulse_width, sampling_rate, lower_limit_frequency, band_width, p_vector_signal_ref);
// 傅里叶变换长度
vsip_length n_fft_len = 2 * n_total_signal_length - 1;
n_fft_len = (vsip_length)ceil(0.5 + log2(n_fft_len));
n_fft_len = (vsip_length)floor(0.5 + pow(2, n_fft_len));
vsip_length fft_len = 2 * total_signal_length - 1;
fft_len = (vsip_length)ceil(0.5 + log2(fft_len));
fft_len = (vsip_length)floor(0.5 + pow(2, fft_len));
// DEBUG
printf("radar: n_fft_len = %ld\n", n_fft_len);
printf("radar: fft_len = %ld\n", fft_len);
// 脉冲压缩
vsip_cvview_f *p_vector_radar_signal_compressed = vsip_cvcreate_f(n_fft_len, VSIP_MEM_NONE);
vsip_cvview_f *p_vector_radar_signal_compressed = vsip_cvcreate_f(fft_len, VSIP_MEM_NONE);
pulse_compress(p_vector_radar_signal_filtered, p_vector_signal_ref,
p_vector_radar_signal_compressed);
// DEBUG
cvdebug_f(p_vector_radar_signal_compressed, "./data/radar_signal_compressed.txt");
outputComplexVector(p_vector_radar_signal_compressed, "./data/radar_signal_compressed.txt");
// 根据 30 阈值筛选
vsip_cvview_f *p_vector_radar_signal_reduced = vsip_cvcreate_f(n_fft_len, VSIP_MEM_NONE);
vsip_cvview_f *p_vector_radar_signal_reduced = vsip_cvcreate_f(fft_len, VSIP_MEM_NONE);
detect_signal(p_vector_radar_signal_compressed, 30.0f, p_vector_radar_signal_reduced);
// DEBUG
cvdebug_f(p_vector_radar_signal_reduced, "./data/radar_signal_reduced.txt");
outputComplexVector(p_vector_radar_signal_reduced, "./data/radar_signal_reduced.txt");
// 检测目标并且输出距离
// 采样间隔
vsip_scalar_f f_delta_time = 1.0f / f_freq_sampling;
vsip_scalar_f delta_time = 1.0f / sampling_rate;
// 上一个峰值的时间
vsip_scalar_f f_prev_time = 0.0f;
vsip_scalar_f prev_time = 0.0f;
// 在向量中的下标
vsip_length n_index = 0;
vsip_length index = 0;
while (n_index < n_fft_len - 1)
while (index < fft_len - 1)
{
// 当前时间
vsip_scalar_f f_curr_time = (vsip_scalar_f)n_index * f_delta_time;
vsip_scalar_f curr_time = (vsip_scalar_f)index * delta_time;
// 下一个时间
vsip_scalar_f f_next_time = (vsip_scalar_f)(n_index + 1) * f_delta_time;
vsip_scalar_f next_time = (vsip_scalar_f)(index + 1) * delta_time;
// 当前幅值
vsip_scalar_f f_curr_mag =
vsip_cmag_f(vsip_cvget_f(p_vector_radar_signal_reduced, n_index));
vsip_scalar_f curr_mag =
vsip_cmag_f(vsip_cvget_f(p_vector_radar_signal_reduced, index));
// 下一个幅值
vsip_scalar_f f_next_mag =
vsip_cmag_f(vsip_cvget_f(p_vector_radar_signal_reduced, n_index + 1));
vsip_scalar_f next_mag =
vsip_cmag_f(vsip_cvget_f(p_vector_radar_signal_reduced, index + 1));
if (f_curr_mag <= f_next_mag)
if (curr_mag <= next_mag)
{
// 若仍然处于递增阶段，则继续向后搜索
n_index++;
index++;
}
else
{
// 当前幅值大于前一个幅值，且大于后一个幅值，说明是一个峰值
if (f_prev_time == 0.0f)
if (prev_time == 0.0f)
{
// 第一个目标，记录时间
f_prev_time = f_curr_time;
printf("detect: time = %fs\n", f_curr_time);
prev_time = curr_time;
printf("detect: time = %fs\n", curr_time);
}
else
{
// 与上一个目标的距离
vsip_scalar_f f_distance = 3e8 * (f_curr_time - f_prev_time) / 2.0f;
vsip_scalar_f distance = 3e8 * (curr_time - prev_time) / 2.0f;
// 记录时间
f_prev_time = f_curr_time;
printf("detect: time = %fs, distance = %fm\n", f_curr_time, f_distance);
prev_time = curr_time;
printf("detect: time = %fs, distance = %fm\n", curr_time, distance);
}
while (f_curr_mag > f_next_mag)
while (curr_mag > next_mag)
{
// 在递减阶段，继续向后搜索
n_index++;
f_curr_mag = vsip_cmag_f(vsip_cvget_f(p_vector_radar_signal_reduced, n_index));
f_next_mag = vsip_cmag_f(vsip_cvget_f(p_vector_radar_signal_reduced, n_index + 1));
index++;
curr_mag = vsip_cmag_f(vsip_cvget_f(p_vector_radar_signal_reduced, index));
next_mag = vsip_cmag_f(vsip_cvget_f(p_vector_radar_signal_reduced, index + 1));
}
}
}

186
src/signal.c
View File

@ -1,24 +1,102 @@
#include "signal.h"
#include "hamming.h"
#include "utils.h"
#include "tool.h"
#include <time.h>
// 信号翻转
void cvflip_f(vsip_cvview_f *p_vector_src, vsip_cvview_f *p_vector_dst)
{
if (p_vector_src == NULL)
{
fprintf(stderr, "cvflip_f: p_vector is NULL\n");
return;
}
else
{
;
}
vsip_length n_length = vsip_cvgetlength_f(p_vector_src);
if (p_vector_dst == NULL)
{
fprintf(stderr, "cvflip_f: p_vector_dst is NULL\n");
return;
}
else if (n_length != vsip_cvgetlength_f(p_vector_dst))
{
fprintf(stderr, "cvflip_f: p_vector_src and p_vector_dst have different lengths\n");
return;
}
else
{
;
}
for (vsip_index n_index = 0; n_index < n_length; n_index++)
{
vsip_cvput_f(p_vector_dst, n_index, vsip_cvget_f(p_vector_src, n_length - n_index - 1));
}
}
void cvpad_f(vsip_cvview_f *p_vector_src, vsip_cvview_f *p_vector_dst)
{
if (p_vector_src == NULL)
{
fprintf(stderr, "cvpad_f: p_vector is NULL\n");
return;
}
else
{
;
}
vsip_length n_length_src = vsip_cvgetlength_f(p_vector_src);
if (p_vector_dst == NULL)
{
fprintf(stderr, "cvpad_f: p_vector_dst is NULL\n");
return;
}
else if (n_length_src > vsip_cvgetlength_f(p_vector_dst))
{
fprintf(stderr, "cvpad_f: p_vector_src is longer than p_vector_dst\n");
return;
}
else
{
;
}
vsip_length n_length_dst = vsip_cvgetlength_f(p_vector_dst);
for (vsip_index n_index = 0; n_index < n_length_src; n_index++)
{
vsip_cvput_f(p_vector_dst, n_index, vsip_cvget_f(p_vector_src, n_index));
}
for (vsip_index n_index = n_length_src; n_index < n_length_dst; n_index++)
{
vsip_cvput_f(p_vector_dst, n_index, vsip_cmplx_f(0.0f, 0.0f));
}
}
void generate_lfm_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
vsip_scalar_f f_freq_low, vsip_scalar_f f_band_width,
vsip_cvview_f *p_vector_dst)
{
// 信号长度（样本数量）
vsip_length n_signal_length = (vsip_length)(0.5f + f_tau * f_freq_sampling);
vsip_length signal_length = (vsip_length)(0.5f + f_tau * f_freq_sampling);
if (p_vector_dst == NULL)
{
fprintf(stderr, "generate_lfm_signal: p_vector_dst is NULL.\n");
return;
}
else if (vsip_cvgetlength_f(p_vector_dst) != n_signal_length)
else if (vsip_cvgetlength_f(p_vector_dst) != signal_length)
{
fprintf(stderr,
"generate_lfm_signal: p_vector_dst length is not equal to n_signal_length.\n");
"generate_lfm_signal: p_vector_dst length is not equal to signal_length.\n");
return;
}
else
@ -27,11 +105,11 @@ void generate_lfm_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
}
// 初始化时间向量
vsip_vview_f *p_vector_time = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_time = vsip_vcreate_f(signal_length, VSIP_MEM_NONE);
// 初始化中间变量
vsip_vview_f *p_vector_temp_0 = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_temp_0 = vsip_vcreate_f(signal_length, VSIP_MEM_NONE);
// 初始化中间变量
vsip_vview_f *p_vector_temp_1 = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_temp_1 = vsip_vcreate_f(signal_length, VSIP_MEM_NONE);
// 生成时间向量
vsip_vramp_f(0.0f, 1.0f / f_freq_sampling, p_vector_time);
@ -58,17 +136,17 @@ void generate_lfm_signal_real(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling
vsip_vview_f *p_vector_dst)
{
// 信号长度（样本数量）
vsip_length n_signal_length = (vsip_length)(0.5f + f_tau * f_freq_sampling);
vsip_length signal_length = (vsip_length)(0.5f + f_tau * f_freq_sampling);
if (p_vector_dst == NULL)
{
fprintf(stderr, "generate_lfm_signal: p_vector_dst is NULL.\n");
return;
}
else if (vsip_vgetlength_f(p_vector_dst) != n_signal_length)
else if (vsip_vgetlength_f(p_vector_dst) != signal_length)
{
fprintf(stderr,
"generate_lfm_signal: p_vector_dst length is not equal to n_signal_length.\n");
"generate_lfm_signal: p_vector_dst length is not equal to signal_length.\n");
return;
}
else
@ -77,11 +155,11 @@ void generate_lfm_signal_real(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling
}
// 初始化时间向量
vsip_vview_f *p_vector_time = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_time = vsip_vcreate_f(signal_length, VSIP_MEM_NONE);
// 初始化中间变量
vsip_vview_f *p_vector_temp_0 = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_temp_0 = vsip_vcreate_f(signal_length, VSIP_MEM_NONE);
// 初始化中间变量
vsip_vview_f *p_vector_temp_1 = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_temp_1 = vsip_vcreate_f(signal_length, VSIP_MEM_NONE);
// 生成时间向量
vsip_vramp_f(0.0f, 1.0f / f_freq_sampling, p_vector_time);
@ -114,20 +192,20 @@ void generate_radar_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
vsip_scalar_f f_total_time = f_tau + f_delay_time;
// 延迟信号长度（样本数量）
vsip_length n_delay_signal_length = (vsip_length)(0.5f + f_delay_time * f_freq_sampling);
vsip_length delay_signal_length = (vsip_length)(0.5f + f_delay_time * f_freq_sampling);
// 总信号长度（样本数量）
vsip_length n_total_signal_length = (vsip_length)(0.5f + f_total_time * f_freq_sampling);
vsip_length total_signal_length = (vsip_length)(0.5f + f_total_time * f_freq_sampling);
if (p_vector_dst == NULL)
{
fprintf(stderr, "generate_radar_signal: p_vector_dst is NULL.\n");
return;
}
else if (vsip_vgetlength_f(p_vector_dst) != n_total_signal_length)
else if (vsip_vgetlength_f(p_vector_dst) != total_signal_length)
{
fprintf(
stderr,
"generate_radar_signal: p_vector_dst length is not equal to n_total_signal_length.\n");
"generate_radar_signal: p_vector_dst length is not equal to total_signal_length.\n");
return;
}
else
@ -136,39 +214,39 @@ void generate_radar_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
}
// LFM 信号长度
vsip_length n_signal_length = (vsip_length)(0.5f + f_tau * f_freq_sampling);
vsip_length signal_length = (vsip_length)(0.5f + f_tau * f_freq_sampling);
// 第一个目标返回的信号
vsip_vview_f *p_vector_signal_0 = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_signal_0 = vsip_vcreate_f(signal_length, VSIP_MEM_NONE);
// 第二个目标返回的信号
vsip_vview_f *p_vector_signal_1 = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_signal_1 = vsip_vcreate_f(signal_length, VSIP_MEM_NONE);
generate_lfm_signal_real(f_tau, f_freq_sampling, f_freq_low, f_band_width, p_vector_signal_0);
generate_lfm_signal_real(f_tau, f_freq_sampling, f_freq_low, f_band_width, p_vector_signal_1);
// 延长原始信号向量
vsip_vview_f *p_vector_signal_0_extended = vsip_vcreate_f(n_total_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_signal_0_extended = vsip_vcreate_f(total_signal_length, VSIP_MEM_NONE);
// 延长原始信号向量
vsip_vview_f *p_vector_signal_1_extended = vsip_vcreate_f(n_total_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_signal_1_extended = vsip_vcreate_f(total_signal_length, VSIP_MEM_NONE);
// 零填充
vsip_vfill_f(0.0f, p_vector_signal_0_extended);
vsip_vfill_f(0.0f, p_vector_signal_1_extended);
// 拷贝数据
for (vsip_length n_index = 0; n_index < n_signal_length; n_index++)
for (vsip_length index = 0; index < signal_length; index++)
{
// 原始信号
vsip_vput_f(p_vector_signal_0_extended, n_index, vsip_vget_f(p_vector_signal_0, n_index));
vsip_vput_f(p_vector_signal_0_extended, index, vsip_vget_f(p_vector_signal_0, index));
// 延迟信号
vsip_vput_f(p_vector_signal_1_extended, n_index + n_delay_signal_length,
vsip_vget_f(p_vector_signal_1, n_index));
vsip_vput_f(p_vector_signal_1_extended, index + delay_signal_length,
vsip_vget_f(p_vector_signal_1, index));
}
// 叠加信号
vsip_vadd_f(p_vector_signal_0_extended, p_vector_signal_1_extended, p_vector_dst);
// 高斯白噪声，SNR=0dB
vsip_vview_f *p_vector_wgn_signal = vsip_vcreate_f(n_total_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_wgn_signal = vsip_vcreate_f(total_signal_length, VSIP_MEM_NONE);
generate_wgn_signal(p_vector_dst, 0.0f, p_vector_wgn_signal);
// 叠加噪声
@ -185,16 +263,16 @@ void generate_radar_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
void generate_wgn_signal(vsip_vview_f *p_vector_signal, vsip_scalar_f f_snr,
vsip_vview_f *p_vector_dst)
{
vsip_length n_length = vsip_vgetlength_f(p_vector_signal);
vsip_length length = vsip_vgetlength_f(p_vector_signal);
if (p_vector_dst == NULL)
{
fprintf(stderr, "generate_wgn_signal: p_vector_dst is NULL.\n");
return;
}
else if (vsip_vgetlength_f(p_vector_dst) != n_length)
else if (vsip_vgetlength_f(p_vector_dst) != length)
{
fprintf(stderr, "generate_wgn_signal: p_vector_dst length is not equal to n_length.\n");
fprintf(stderr, "generate_wgn_signal: p_vector_dst length is not equal to length.\n");
return;
}
else
@ -205,7 +283,7 @@ void generate_wgn_signal(vsip_vview_f *p_vector_signal, vsip_scalar_f f_snr,
// 功率信噪比
vsip_scalar_f f_snr_power = vsip_pow_f(10.0f, f_snr / 10.0f);
// 噪声功率
vsip_scalar_f f_noise_power = vsip_vsumsqval_f(p_vector_signal) / (n_length * f_snr_power);
vsip_scalar_f f_noise_power = vsip_vsumsqval_f(p_vector_signal) / (length * f_snr_power);
// 随机生成
vsip_randstate *p_rand_state = vsip_randcreate(time(NULL), 1, 1, VSIP_PRNG);
vsip_vrandn_f(p_rand_state, p_vector_dst);
@ -240,31 +318,31 @@ void pulse_compress(vsip_cvview_f *p_vector_signal_src, vsip_cvview_f *p_vector_
;
}
vsip_length n_signal_src_length = vsip_cvgetlength_f(p_vector_signal_src);
vsip_length n_signal_ref_length = vsip_cvgetlength_f(p_vector_signal_ref);
vsip_length signal_src_length = vsip_cvgetlength_f(p_vector_signal_src);
vsip_length signal_ref_length = vsip_cvgetlength_f(p_vector_signal_ref);
// 求参考信号共轭
vsip_cvconj_f(p_vector_signal_ref, p_vector_signal_ref);
// 翻转参考信号
vsip_cvview_f *p_vector_signal_ref_flipped =
vsip_cvcreate_f(n_signal_ref_length, VSIP_MEM_NONE);
vsip_cvcreate_f(signal_ref_length, VSIP_MEM_NONE);
cvflip_f(p_vector_signal_ref, p_vector_signal_ref_flipped);
// 加汉明窗
vsip_vview_f *p_vector_window = vsip_vcreate_f(n_signal_ref_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_window = vsip_vcreate_f(signal_ref_length, VSIP_MEM_NONE);
vcreate_hamming_f(p_vector_window);
vsip_rcvmul_f(p_vector_window, p_vector_signal_ref_flipped, p_vector_signal_ref);
cvdebug_f(p_vector_signal_ref, "./data/reference_signal.txt");
outputComplexVector(p_vector_signal_ref, "./data/reference_signal.txt");
// 傅里叶变换长度
vsip_length n_fft_len = 2 * n_signal_src_length - 1;
n_fft_len = (vsip_length)ceil(0.5 + log2(n_fft_len));
n_fft_len = (vsip_length)floor(0.5 + pow(2, n_fft_len));
vsip_length fft_len = 2 * signal_src_length - 1;
fft_len = (vsip_length)ceil(0.5 + log2(fft_len));
fft_len = (vsip_length)floor(0.5 + pow(2, fft_len));
if (vsip_cvgetlength_f(p_vector_dst) != n_fft_len)
if (vsip_cvgetlength_f(p_vector_dst) != fft_len)
{
fprintf(stderr, "pulse_compress: p_vector_dst length is not equal to n_fft_len.\n");
fprintf(stderr, "pulse_compress: p_vector_dst length is not equal to fft_len.\n");
return;
}
else
@ -273,18 +351,18 @@ void pulse_compress(vsip_cvview_f *p_vector_signal_src, vsip_cvview_f *p_vector_
}
// 补零向量
vsip_cvview_f *p_vector_signal_src_padded = vsip_cvcreate_f(n_fft_len, VSIP_MEM_NONE);
vsip_cvview_f *p_vector_signal_ref_padded = vsip_cvcreate_f(n_fft_len, VSIP_MEM_NONE);
vsip_cvview_f *p_vector_signal_src_padded = vsip_cvcreate_f(fft_len, VSIP_MEM_NONE);
vsip_cvview_f *p_vector_signal_ref_padded = vsip_cvcreate_f(fft_len, VSIP_MEM_NONE);
// 补零
cvpad_f(p_vector_signal_src, p_vector_signal_src_padded);
cvpad_f(p_vector_signal_ref, p_vector_signal_ref_padded);
// 傅里叶变换
vsip_fft_f *p_fft = vsip_ccfftop_create_f(n_fft_len, 1.0, VSIP_FFT_FWD, 1, 0);
vsip_fft_f *p_ifft = vsip_ccfftop_create_f(n_fft_len, 1.0 / n_fft_len, VSIP_FFT_INV, 1, 0);
vsip_cvview_f *p_vector_signal_src_fft = vsip_cvcreate_f(n_fft_len, VSIP_MEM_NONE);
vsip_cvview_f *p_vector_signal_ref_fft = vsip_cvcreate_f(n_fft_len, VSIP_MEM_NONE);
vsip_fft_f *p_fft = vsip_ccfftop_create_f(fft_len, 1.0, VSIP_FFT_FWD, 1, 0);
vsip_fft_f *p_ifft = vsip_ccfftop_create_f(fft_len, 1.0 / fft_len, VSIP_FFT_INV, 1, 0);
vsip_cvview_f *p_vector_signal_src_fft = vsip_cvcreate_f(fft_len, VSIP_MEM_NONE);
vsip_cvview_f *p_vector_signal_ref_fft = vsip_cvcreate_f(fft_len, VSIP_MEM_NONE);
vsip_ccfftop_f(p_fft, p_vector_signal_src_padded, p_vector_signal_src_fft);
vsip_ccfftop_f(p_fft, p_vector_signal_ref_padded, p_vector_signal_ref_fft);
@ -324,11 +402,11 @@ void detect_signal(vsip_cvview_f *p_vector_signal, vsip_scalar_f f_threshold,
;
}
vsip_length n_signal_length = vsip_cvgetlength_f(p_vector_signal);
vsip_length signal_length = vsip_cvgetlength_f(p_vector_signal);
if (vsip_cvgetlength_f(p_vector_dst) != n_signal_length)
if (vsip_cvgetlength_f(p_vector_dst) != signal_length)
{
fprintf(stderr, "detect_signal: p_vector_dst length is not equal to n_signal_length.\n");
fprintf(stderr, "detect_signal: p_vector_dst length is not equal to signal_length.\n");
return;
}
else
@ -336,18 +414,18 @@ void detect_signal(vsip_cvview_f *p_vector_signal, vsip_scalar_f f_threshold,
;
}
for (vsip_length n_index = 0; n_index < n_signal_length; n_index++)
for (vsip_length index = 0; index < signal_length; index++)
{
vsip_scalar_f f_abs = vsip_cmag_f(vsip_cvget_f(p_vector_signal, n_index));
vsip_scalar_f f_abs = vsip_cmag_f(vsip_cvget_f(p_vector_signal, index));
if (fabs(f_abs) < f_threshold && fabs(f_abs) < f_threshold)
{
// 低于阈值的信号置零
vsip_cvput_f(p_vector_dst, n_index, vsip_cmplx_f(0.0f, 0.0f));
vsip_cvput_f(p_vector_dst, index, vsip_cmplx_f(0.0f, 0.0f));
}
else
{
// 大于阈值的信号保留
vsip_cvput_f(p_vector_dst, n_index, vsip_cvget_f(p_vector_signal, n_index));
vsip_cvput_f(p_vector_dst, index, vsip_cvget_f(p_vector_signal, index));
}
}
}

47
src/tool.c Executable file
View File

@ -0,0 +1,47 @@
#include "tool.h"
void outputRealVector(vsip_vview_f *p_vector, char *p_name)
{
if (p_vector == NULL)
{
fprintf(stderr, "outputRealVector: p_vector is NULL\n");
return;
}
FILE *p_file = fopen(p_name, "w");
if (p_file == NULL)
{
fprintf(stderr, "vdebug_f: unable to open file `%s`\n", p_name);
return;
}
vsip_length n_length = vsip_vgetlength_f(p_vector);
for (vsip_index n_index = 0; n_index < n_length; n_index++)
{
fprintf(p_file, "%f\n", vsip_vget_f(p_vector, n_index));
}
fclose(p_file);
}
void outputComplexVector(vsip_cvview_f *p_vector,char *p_name)
{
if (p_vector == NULL)
{
fprintf(stderr, "outputRealVector: p_vector is NULL\n");
return;
}
FILE *p_file = fopen(p_name, "w");
if (p_file == NULL)
{
fprintf(stderr, "cvdebug_f: unable to open file `%s`\n", p_name);
return;
}
vsip_length n_length = vsip_cvgetlength_f(p_vector);
for (vsip_index n_index = 0; n_index < n_length; n_index++)
{
vsip_cscalar_f c_value = vsip_cvget_f(p_vector, n_index);
fprintf(p_file, "%+9.4f%+9.4fj\n", vsip_real_f(c_value), vsip_imag_f(c_value));
}
fclose(p_file);
}

147
src/utils.c
View File

@ -1,147 +0,0 @@
#include "utils.h"
void vdump_f(vsip_vview_f *p_vector, FILE *p_file)
{
if (p_vector == NULL)
{
fprintf(stderr, "vdump_f: p_vector is NULL\n");
return;
}
else
{
;
}
vsip_length n_length = vsip_vgetlength_f(p_vector);
for (vsip_index n_index = 0; n_index < n_length; n_index++)
{
fprintf(p_file, "%f\n", vsip_vget_f(p_vector, n_index));
}
}
void cvdump_f(vsip_cvview_f *p_vector, FILE *p_file)
{
if (p_vector == NULL)
{
fprintf(stderr, "vdump_f: p_vector is NULL\n");
return;
}
else
{
;
}
vsip_length n_length = vsip_cvgetlength_f(p_vector);
for (vsip_index n_index = 0; n_index < n_length; n_index++)
{
vsip_cscalar_f c_value = vsip_cvget_f(p_vector, n_index);
fprintf(p_file, "%+9.4f%+9.4fj\n", vsip_real_f(c_value), vsip_imag_f(c_value));
}
}
void vdebug_f(vsip_vview_f *p_vector, char *p_name)
{
FILE *p_file = fopen(p_name, "w");
if (p_file == NULL)
{
fprintf(stderr, "vdebug_f: unable to open file `%s`\n", p_name);
return;
}
else
{
;
}
vdump_f(p_vector, p_file);
fclose(p_file);
}
void cvdebug_f(vsip_cvview_f *p_vector, char *p_name)
{
FILE *p_file = fopen(p_name, "w");
if (p_file == NULL)
{
fprintf(stderr, "cvdebug_f: unable to open file `%s`\n", p_name);
return;
}
else
{
;
}
cvdump_f(p_vector, p_file);
fclose(p_file);
}
void cvflip_f(vsip_cvview_f *p_vector_src, vsip_cvview_f *p_vector_dst)
{
if (p_vector_src == NULL)
{
fprintf(stderr, "cvflip_f: p_vector is NULL\n");
return;
}
else
{
;
}
vsip_length n_length = vsip_cvgetlength_f(p_vector_src);
if (p_vector_dst == NULL)
{
fprintf(stderr, "cvflip_f: p_vector_dst is NULL\n");
return;
}
else if (n_length != vsip_cvgetlength_f(p_vector_dst))
{
fprintf(stderr, "cvflip_f: p_vector_src and p_vector_dst have different lengths\n");
return;
}
else
{
;
}
for (vsip_index n_index = 0; n_index < n_length; n_index++)
{
vsip_cvput_f(p_vector_dst, n_index, vsip_cvget_f(p_vector_src, n_length - n_index - 1));
}
}
void cvpad_f(vsip_cvview_f *p_vector_src, vsip_cvview_f *p_vector_dst)
{
if (p_vector_src == NULL)
{
fprintf(stderr, "cvpad_f: p_vector is NULL\n");
return;
}
else
{
;
}
vsip_length n_length_src = vsip_cvgetlength_f(p_vector_src);
if (p_vector_dst == NULL)
{
fprintf(stderr, "cvpad_f: p_vector_dst is NULL\n");
return;
}
else if (n_length_src > vsip_cvgetlength_f(p_vector_dst))
{
fprintf(stderr, "cvpad_f: p_vector_src is longer than p_vector_dst\n");
return;
}
else
{
;
}
vsip_length n_length_dst = vsip_cvgetlength_f(p_vector_dst);
for (vsip_index n_index = 0; n_index < n_length_src; n_index++)
{
vsip_cvput_f(p_vector_dst, n_index, vsip_cvget_f(p_vector_src, n_index));
}
for (vsip_index n_index = n_length_src; n_index < n_length_dst; n_index++)
{
vsip_cvput_f(p_vector_dst, n_index, vsip_cmplx_f(0.0f, 0.0f));
}
}

0
plot.py → verification/plot.py
View File