c1_std5.c

mmo 信道估计算法 matlab 仿真 实现了无线信道环境下的信道估计

/* Include files */
#include "std5_sfun.h"
#include "c1_std5.h"
#define CHARTINSTANCE_CHARTNUMBER       (chartInstance.chartNumber)
#define CHARTINSTANCE_INSTANCENUMBER    (chartInstance.instanceNumber)
#include "std5_sfun_debug_macros.h"

/* Type Definitions */

/* Named Constants */
#define c1_IN_NO_ACTIVE_CHILD           (0)

/* Variable Declarations */

/* Variable Definitions */
static SFc1_std5InstanceStruct chartInstance;

/* Function Declarations */
static void initialize_c1_std5(void);
static void initialize_params_c1_std5(void);
static void enable_c1_std5(void);
static void disable_c1_std5(void);
static void finalize_c1_std5(void);
static void sf_c1_std5(void);
static void c1_eML_blk_kernel(creal_T *c1_b_input_signal, real_T
 c1_b_freq_offset, creal_T *c1_b_offset_sig);
static void c1_exp(creal_T *c1_x, creal_T *c1_b_x);
static const mxArray *c1_sf_marshall(void *c1_chartInstance, void *c1_u);
static const mxArray *c1_b_sf_marshall(void *c1_chartInstance, void *c1_u);
static const mxArray *c1_c_sf_marshall(void *c1_chartInstance, void *c1_u);
static const mxArray *c1_d_sf_marshall(void *c1_chartInstance, void *c1_u);
static const mxArray *c1_e_sf_marshall(void *c1_chartInstance, void *c1_u);
static const mxArray *c1_f_sf_marshall(void *c1_chartInstance, void *c1_u);
static const mxArray *c1_g_sf_marshall(void *c1_chartInstance, void *c1_u);
static creal_T *c1_offset_sig(void);
static creal_T *c1_input_signal(void);
static real_T *c1_freq_offset(void);
static void init_dsm_address_info(void);

/* Function Definitions */
static void initialize_c1_std5(void)
{
  _sfTime_ = (real_T)ssGetT(chartInstance.S);
  chartInstance.c1_is_active_c1_std5 = 0U;
}

static void initialize_params_c1_std5(void)
{
}

static void enable_c1_std5(void)
{
}

static void disable_c1_std5(void)
{
}

static void finalize_c1_std5(void)
{
}

static void sf_c1_std5(void)
{
  uint8_T c1_previousEvent;
  int32_T c1_i0;
  creal_T c1_dcv0[480];
  creal_T c1_dcv1[480];
  int32_T c1_i1;
  _sfTime_ = (real_T)ssGetT(chartInstance.S);
  _SFD_DATA_RANGE_CHECK(*c1_freq_offset(), 1U);
  c1_previousEvent = _sfEvent_;
  _sfEvent_ = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG,0);
  for(c1_i0 = 0; c1_i0 < 480; c1_i0 = c1_i0 + 1) {
    c1_dcv0[c1_i0].re = c1_input_signal()[c1_i0].re;
    c1_dcv0[c1_i0].im = c1_input_signal()[c1_i0].im;
  }
  c1_eML_blk_kernel((creal_T *)c1_dcv0, *c1_freq_offset(), (creal_T *)c1_dcv1);
  for(c1_i1 = 0; c1_i1 < 480; c1_i1 = c1_i1 + 1) {
    c1_offset_sig()[c1_i1].re = c1_dcv1[c1_i1].re;
    c1_offset_sig()[c1_i1].im = c1_dcv1[c1_i1].im;
  }
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,0);
  _sfEvent_ = c1_previousEvent;
  sf_debug_check_for_state_inconsistency(_std5MachineNumber_,
   chartInstance.chartNumber, chartInstance.instanceNumber);
}

static void c1_eML_blk_kernel(creal_T *c1_b_input_signal, real_T
 c1_b_freq_offset, creal_T *c1_b_offset_sig)
{
  creal_T c1_phase_rotation2[480];
  real_T c1_time_base2[480];
  real_T c1_time_base1[480];
  real_T c1_n_signals;
  int32_T c1_i2;
  real_T c1_A[480];
  int32_T c1_i3;
  real_T c1_x[480];
  int32_T c1_i4;
  int32_T c1_i5;
  real_T c1_dv0[480];
  int32_T c1_i6;
  int32_T c1_i7;
  real_T c1_u[480];
  const mxArray *c1_y = NULL;
  creal_T c1_dc0;
  int32_T c1_i8;
  creal_T c1_dcv2[480];
  creal_T c1_dcv3[480];
  int32_T c1_i9;
  int32_T c1_i10;
  sf_debug_symbol_scope_push(7U, 0U);
  sf_debug_symbol_scope_add("phase_rotation2", &c1_phase_rotation2,
   c1_g_sf_marshall);
  sf_debug_symbol_scope_add("time_base2", &c1_time_base2, c1_f_sf_marshall);
  sf_debug_symbol_scope_add("time_base1", &c1_time_base1, c1_e_sf_marshall);
  sf_debug_symbol_scope_add("n_signals", &c1_n_signals, c1_d_sf_marshall);
  sf_debug_symbol_scope_add("offset_sig", c1_b_offset_sig, c1_c_sf_marshall);
  sf_debug_symbol_scope_add("freq_offset", &c1_b_freq_offset, c1_b_sf_marshall);
  sf_debug_symbol_scope_add("input_signal", c1_b_input_signal, c1_sf_marshall);
  CV_EML_FCN(0, 0);
  /* timing search window size */
  /*   */
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,16);
  c1_n_signals = 480.0;
  /*  create a timebase */
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,19);
  for(c1_i2 = 0; c1_i2 < 480; c1_i2 = c1_i2 + 1) {
    c1_A[c1_i2] = (real_T)c1_i2;
  }
  for(c1_i3 = 0; c1_i3 < 480; c1_i3 = c1_i3 + 1) {
    c1_x[c1_i3] = c1_A[c1_i3];
  }
  for(c1_i4 = 0; c1_i4 < 480; c1_i4 = c1_i4 + 1) {
    c1_time_base1[c1_i4] = c1_x[c1_i4] / 2.0E+007;
  }
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,20);
  for(c1_i5 = 0; c1_i5 < 480; c1_i5 = c1_i5 + 1) {
    c1_dv0[c1_i5] = c1_time_base1[c1_i5];
  }
  for(c1_i6 = 0; c1_i6 < 480; c1_i6 = c1_i6 + 1) {
    c1_time_base2[c1_i6] = c1_dv0[c1_i6];
  }
  sf_mex_printf("%s =\\n", "time_base2");
  for(c1_i7 = 0; c1_i7 < 480; c1_i7 = c1_i7 + 1) {
    c1_u[c1_i7] = c1_dv0[c1_i7];
  }
  c1_y = NULL;
  sf_mex_assign(&c1_y, sf_mex_create(&c1_u, "y", 0, 0U, 1U, 1, 480));
  sf_mex_call("disp", 0U, 1U, 14, c1_y);
  /*  create phase_rotation vector */
  /*  phase_rotation1 = repmat(exp(1i*2*pi*freq_offset*time_base2),n_signals,1); */
  /*  phase_rotation2=ones(1,480); */
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,24);
  c1_dc0.re = c1_b_freq_offset * 0.0;
  c1_dc0.im = c1_b_freq_offset * 6.2831853071795862E+000;
  for(c1_i8 = 0; c1_i8 < 480; c1_i8 = c1_i8 + 1) {
    c1_dcv2[c1_i8].re = c1_time_base2[c1_i8] * c1_dc0.re;
    c1_dcv2[c1_i8].im = c1_time_base2[c1_i8] * c1_dc0.im;
  }
  c1_exp((creal_T *)c1_dcv2, (creal_T *)c1_dcv3);
  for(c1_i9 = 0; c1_i9 < 480; c1_i9 = c1_i9 + 1) {
    c1_phase_rotation2[c1_i9].re = c1_dcv3[c1_i9].re;
    c1_phase_rotation2[c1_i9].im = c1_dcv3[c1_i9].im;
  }
  /*  and apply it to the signal; */
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,26);
  for(c1_i10 = 0; c1_i10 < 480; c1_i10 = c1_i10 + 1) {
    c1_b_offset_sig[c1_i10].re = c1_b_input_signal[c1_i10].re *
      c1_phase_rotation2[c1_i10].re - c1_b_input_signal[c1_i10].im *
      c1_phase_rotation2[c1_i10].im;
    c1_b_offset_sig[c1_i10].im = c1_b_input_signal[c1_i10].re *
      c1_phase_rotation2[c1_i10].im + c1_b_input_signal[c1_i10].im *
      c1_phase_rotation2[c1_i10].re;
  }
  /*  offset_sig = input_signal; */
  /*  offset_sig = input_signal.*phase_rotation; */
  /*     start_search=130; */
  /*     end_search=200; */
  /*      */
  /*  phase_rotation3=exp(-1i*2*pi*freq_offset*time_base2); */
  /*  % and apply it to the signal; */
  /*   offset_sig =times(offset_sig,phase_rotation3); */
  /*      */
  /*  else */
  /*     thres_idx = sim_consts.ExtraNoiseSamples; */
  /*  end; */
  /*   */
  /*  % check if the packet has been detected too late,  */
  /*  % > sim_consts.extra_noise_samples + 35 index  */
  /*  % is out of range of the fine timing algorithm */
  /*  % This prevents simulation error for code running out samples */
  /*  if thres_idx > sim_consts.ExtraNoiseSamples + 35 */
  /*     thres_idx = 1; */
  /*  end */
  /*   */
  /*  detected_packet = input_signal(:,thres_idx:length(input_signal)); */
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,-26);
  sf_debug_symbol_scope_pop();
}

static void c1_exp(creal_T *c1_x, creal_T *c1_b_x)
{
  int32_T c1_i11;
  real_T c1_k;
  real_T c1_b_k;
  creal_T c1_xk;
  real_T c1_r;
  for(c1_i11 = 0; c1_i11 < 480; c1_i11 = c1_i11 + 1) {
    c1_b_x[c1_i11].re = c1_x[c1_i11].re;
    c1_b_x[c1_i11].im = c1_x[c1_i11].im;
  }
  for(c1_k = 1.0; c1_k <= 480.0; c1_k = c1_k + 1.0) {
    c1_b_k = c1_k;
    c1_xk.re = c1_b_x[(int32_T)_SFD_EML_ARRAY_BOUNDS_CHECK("x",
     (int32_T)_SFD_INTEGER_CHECK("k", c1_b_k), 1, 480, 1) - 1].re;
    c1_xk.im = c1_b_x[(int32_T)_SFD_EML_ARRAY_BOUNDS_CHECK("x",
     (int32_T)_SFD_INTEGER_CHECK("k", c1_b_k), 1, 480, 1) - 1].im;
    c1_r = exp(c1_xk.re);
    c1_b_x[(int32_T)_SFD_EML_ARRAY_BOUNDS_CHECK("x",
     (int32_T)_SFD_INTEGER_CHECK("k", c1_b_k), 1, 480, 1) - 1].re = c1_r *
      cos(c1_xk.im);
    c1_b_x[(int32_T)_SFD_EML_ARRAY_BOUNDS_CHECK("x",
     (int32_T)_SFD_INTEGER_CHECK("k", c1_b_k), 1, 480, 1) - 1].im = c1_r *
      sin(c1_xk.im);
  }
}

static const mxArray *c1_sf_marshall(void *c1_chartInstance, void *c1_u)
{
  const mxArray *c1_y = NULL;
  int32_T c1_i12;
  creal_T c1_b_u[480];
  const mxArray *c1_b_y = NULL;
  c1_y = NULL;
  for(c1_i12 = 0; c1_i12 < 480; c1_i12 = c1_i12 + 1) {
    c1_b_u[c1_i12].re = (*(creal_T (*)[480])c1_u)[c1_i12].re;
    c1_b_u[c1_i12].im = (*(creal_T (*)[480])c1_u)[c1_i12].im;
  }
  c1_b_y = NULL;
  sf_mex_assign(&c1_b_y, sf_mex_create(&c1_b_u, "y", 0, 1U, 1U, 1, 480));
  sf_mex_assign(&c1_y, c1_b_y);
  return c1_y;
}

static const mxArray *c1_b_sf_marshall(void *c1_chartInstance, void *c1_u)
{
  const mxArray *c1_y = NULL;
  real_T c1_b_u;
  const mxArray *c1_b_y = NULL;
  c1_y = NULL;
  c1_b_u = *(real_T *)c1_u;
  c1_b_y = NULL;
  sf_mex_assign(&c1_b_y, sf_mex_create(&c1_b_u, "y", 0, 0U, 0U, 0));
  sf_mex_assign(&c1_y, c1_b_y);
  return c1_y;
}

static const mxArray *c1_c_sf_marshall(void *c1_chartInstance, void *c1_u)
{
  const mxArray *c1_y = NULL;
  int32_T c1_i13;
  creal_T c1_b_u[480];
  const mxArray *c1_b_y = NULL;
  c1_y = NULL;
  for(c1_i13 = 0; c1_i13 < 480; c1_i13 = c1_i13 + 1) {
    c1_b_u[c1_i13].re = (*(creal_T (*)[480])c1_u)[c1_i13].re;
    c1_b_u[c1_i13].im = (*(creal_T (*)[480])c1_u)[c1_i13].im;
  }
  c1_b_y = NULL;
  sf_mex_assign(&c1_b_y, sf_mex_create(&c1_b_u, "y", 0, 1U, 1U, 1, 480));
  sf_mex_assign(&c1_y, c1_b_y);
  return c1_y;
}

static const mxArray *c1_d_sf_marshall(void *c1_chartInstance, void *c1_u)
{
  const mxArray *c1_y = NULL;
  real_T c1_b_u;
  const mxArray *c1_b_y = NULL;
  c1_y = NULL;
  c1_b_u = *(real_T *)c1_u;
  c1_b_y = NULL;
  sf_mex_assign(&c1_b_y, sf_mex_create(&c1_b_u, "y", 0, 0U, 0U, 0));
  sf_mex_assign(&c1_y, c1_b_y);
  return c1_y;
}

static const mxArray *c1_e_sf_marshall(void *c1_chartInstance, void *c1_u)
{
  const mxArray *c1_y = NULL;
  int32_T c1_i14;
  real_T c1_b_u[480];
  const mxArray *c1_b_y = NULL;
  c1_y = NULL;
  for(c1_i14 = 0; c1_i14 < 480; c1_i14 = c1_i14 + 1) {
    c1_b_u[c1_i14] = (*(real_T (*)[480])c1_u)[c1_i14];
  }
  c1_b_y = NULL;
  sf_mex_assign(&c1_b_y, sf_mex_create(&c1_b_u, "y", 0, 0U, 1U, 2, 1, 480));
  sf_mex_assign(&c1_y, c1_b_y);
  return c1_y;
}

static const mxArray *c1_f_sf_marshall(void *c1_chartInstance, void *c1_u)
{
  const mxArray *c1_y = NULL;
  int32_T c1_i15;
  real_T c1_b_u[480];
  const mxArray *c1_b_y = NULL;
  c1_y = NULL;
  for(c1_i15 = 0; c1_i15 < 480; c1_i15 = c1_i15 + 1) {
    c1_b_u[c1_i15] = (*(real_T (*)[480])c1_u)[c1_i15];
  }
  c1_b_y = NULL;
  sf_mex_assign(&c1_b_y, sf_mex_create(&c1_b_u, "y", 0, 0U, 1U, 1, 480));
  sf_mex_assign(&c1_y, c1_b_y);
  return c1_y;
}

static const mxArray *c1_g_sf_marshall(void *c1_chartInstance, void *c1_u)
{
  const mxArray *c1_y = NULL;
  int32_T c1_i16;
  creal_T c1_b_u[480];
  const mxArray *c1_b_y = NULL;
  c1_y = NULL;
  for(c1_i16 = 0; c1_i16 < 480; c1_i16 = c1_i16 + 1) {
    c1_b_u[c1_i16].re = (*(creal_T (*)[480])c1_u)[c1_i16].re;
    c1_b_u[c1_i16].im = (*(creal_T (*)[480])c1_u)[c1_i16].im;
  }
  c1_b_y = NULL;