c1_snr_estimation.c

FFH, pre-hopping anti-jamming system

/* Include files */
#include "SNR_ESTIMATION_sfun.h"
#include "c1_SNR_ESTIMATION.h"
#define CHARTINSTANCE_CHARTNUMBER       (chartInstance.chartNumber)
#define CHARTINSTANCE_INSTANCENUMBER    (chartInstance.instanceNumber)
#include "SNR_ESTIMATION_sfun_debug_macros.h"

/* Type Definitions */

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

/* Variable Declarations */

/* Variable Definitions */
static SFc1_SNR_ESTIMATIONInstanceStruct chartInstance;

/* Function Declarations */
static void initialize_c1_SNR_ESTIMATION(void);
static void initialize_params_c1_SNR_ESTIMATION(void);
static void enable_c1_SNR_ESTIMATION(void);
static void disable_c1_SNR_ESTIMATION(void);
static void finalize_c1_SNR_ESTIMATION(void);
static void sf_c1_SNR_ESTIMATION(void);
static real_T c1_eML_blk_kernel(creal_T *c1_b_u);
static void c1_fft(creal_T *c1_x, creal_T *c1_b_y);
static real_T c1_abs(creal_T c1_x);
static real_T c1_mpower(real_T c1_a);
static const mxArray *c1_sf_marshall(void *c1_chartInstance, void *c1_b_u);
static const mxArray *c1_b_sf_marshall(void *c1_chartInstance, void *c1_b_u);
static const mxArray *c1_c_sf_marshall(void *c1_chartInstance, void *c1_b_u);
static const mxArray *c1_d_sf_marshall(void *c1_chartInstance, void *c1_b_u);
static const mxArray *c1_e_sf_marshall(void *c1_chartInstance, void *c1_b_u);
static creal_T *c1_u(void);
static real_T *c1_y(void);
static void init_dsm_address_info(void);

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

static void initialize_params_c1_SNR_ESTIMATION(void)
{
}

static void enable_c1_SNR_ESTIMATION(void)
{
}

static void disable_c1_SNR_ESTIMATION(void)
{
}

static void finalize_c1_SNR_ESTIMATION(void)
{
}

static void sf_c1_SNR_ESTIMATION(void)
{
  uint8_T c1_previousEvent;
  int32_T c1_i0;
  creal_T c1_dcv0[1024];
  _sfTime_ = (real_T)ssGetT(chartInstance.S);
  _SFD_DATA_RANGE_CHECK(*c1_y(), 1U);
  c1_previousEvent = _sfEvent_;
  _sfEvent_ = CALL_EVENT;
  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG,0);
  for(c1_i0 = 0; c1_i0 < 1024; c1_i0 = c1_i0 + 1) {
    c1_dcv0[c1_i0].re = c1_u()[c1_i0].re;
    c1_dcv0[c1_i0].im = c1_u()[c1_i0].im;
  }
  *c1_y() = c1_eML_blk_kernel((creal_T *)c1_dcv0);
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,0);
  _sfEvent_ = c1_previousEvent;
  sf_debug_check_for_state_inconsistency(_SNR_ESTIMATIONMachineNumber_,
   chartInstance.chartNumber, chartInstance.instanceNumber);
}

static real_T c1_eML_blk_kernel(creal_T *c1_b_u)
{
  real_T c1_b_y;
  real_T c1_b;
  real_T c1_a;
  creal_T c1_Y[1024];
  int32_T c1_i1;
  creal_T c1_dcv1[1024];
  creal_T c1_dcv2[1024];
  int32_T c1_i2;
  creal_T c1_b_Y;
  creal_T c1_c_Y;
  real_T c1_A;
  real_T c1_x;
  real_T c1_B;
  int32_T c1_i3;
  static char c1_cv0[31] = { 'E', 'm', 'b', 'e', 'd', 'd', 'e', 'd', 'M', 'A',
    'T', 'L', 'A', 'B', ':', 's', 'q', 'r', 't', ':', 'd',
    'o', 'm', 'a', 'i', 'n', 'E', 'r', 'r', 'o', 'r' };
  char c1_c_u[31];
  const mxArray *c1_c_y = NULL;
  int32_T c1_i4;
  static char c1_cv1[77] = { 'D', 'o', 'm', 'a', 'i', 'n', ' ', 'e', 'r', 'r',
    'o', 'r', '.', ' ', 'T', 'o', ' ', 'c', 'o', 'm', 'p',
    'u', 't', 'e', ' ', 'c', 'o', 'm', 'p', 'l', 'e', 'x', ' ', 'r', 'e', 's',
    'u', 'l', 't', 's', ' ', 'f',
    'r', 'o', 'm', ' ', 'r', 'e', 'a', 'l', ' ', 'x', ',', ' ', 'u', 's', 'e',
    ' ', '\'', 's', 'q', 'r', 't'
    , '(', 'c', 'o', 'm', 'p', 'l', 'e', 'x', '(', 'x', ')', ')', '\'', '.' };
  char c1_d_u[77];
  const mxArray *c1_d_y = NULL;
  real_T c1_b_x;
  real_T c1_e_y;
  sf_debug_symbol_scope_push(5U, 0U);
  sf_debug_symbol_scope_add("b", &c1_b, c1_e_sf_marshall);
  sf_debug_symbol_scope_add("a", &c1_a, c1_d_sf_marshall);
  sf_debug_symbol_scope_add("Y", &c1_Y, c1_c_sf_marshall);
  sf_debug_symbol_scope_add("y", &c1_b_y, c1_b_sf_marshall);
  sf_debug_symbol_scope_add("u", c1_b_u, c1_sf_marshall);
  CV_EML_FCN(0, 0);
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,2);
  for(c1_i1 = 0; c1_i1 < 1024; c1_i1 = c1_i1 + 1) {
    c1_dcv1[c1_i1].re = c1_b_u[c1_i1].re;
    c1_dcv1[c1_i1].im = c1_b_u[c1_i1].im;
  }
  c1_fft((creal_T *)c1_dcv1, (creal_T *)c1_dcv2);
  for(c1_i2 = 0; c1_i2 < 1024; c1_i2 = c1_i2 + 1) {
    c1_Y[c1_i2].re = c1_dcv2[c1_i2].re;
    c1_Y[c1_i2].im = c1_dcv2[c1_i2].im;
  }
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,3);
  c1_b_Y.re = c1_Y[1].re;
  c1_b_Y.im = c1_Y[1].im;
  c1_a = c1_abs(c1_b_Y);
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,4);
  c1_c_Y.re = c1_Y[3].re;
  c1_c_Y.im = c1_Y[3].im;
  c1_b = c1_abs(c1_c_Y);
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,5);
  c1_A = c1_a - c1_b;
  c1_x = c1_mpower(c1_a) + c1_mpower(c1_b);
  c1_B = c1_x;
  if(c1_B < 0.0) {
    for(c1_i3 = 0; c1_i3 < 31; c1_i3 = c1_i3 + 1) {
      c1_c_u[c1_i3] = c1_cv0[c1_i3];
    }
    c1_c_y = NULL;
    sf_mex_assign(&c1_c_y, sf_mex_create(&c1_c_u, "y", 8, 0U, 1U, 2, 1, 31));
    for(c1_i4 = 0; c1_i4 < 77; c1_i4 = c1_i4 + 1) {
      c1_d_u[c1_i4] = c1_cv1[c1_i4];
    }
    c1_d_y = NULL;
    sf_mex_assign(&c1_d_y, sf_mex_create(&c1_d_u, "y", 8, 0U, 1U, 2, 1, 77));
    sf_mex_call("error", 0U, 2U, 14, c1_c_y, 14, c1_d_y);
  }
  c1_B = sqrt(c1_B);
  c1_b_x = c1_A;
  c1_e_y = c1_B;
  c1_b_y = c1_b_x / c1_e_y;
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,-5);
  sf_debug_symbol_scope_pop();
  return c1_b_y;
}

static void c1_fft(creal_T *c1_x, creal_T *c1_b_y)
{
  int32_T c1_i5;
  creal_T c1_b_x[1024];
  int32_T c1_i6;
  creal_T c1_c_x[1024];
  int32_T c1_i7;
  int32_T c1_ix;
  int32_T c1_j;
  int32_T c1_iy;
  int32_T c1_i;
  int32_T c1_b_j;
  uint32_T c1_nu;
  uint32_T c1_ju;
  boolean_T c1_tst;
  int32_T c1_b;
  int32_T c1_a;
  int32_T c1_i1;
  int32_T c1_b_i;
  int32_T c1_b_a;
  int32_T c1_i2;
  creal_T c1_temp;
  int32_T c1_c_a;
  int32_T c1_iDelta;
  int32_T c1_k;
  int32_T c1_istart;
  int32_T c1_d_a;
  real_T c1_theta;
  real_T c1_d_x;
  real_T c1_e_x;
  real_T c1_f_x;
  real_T c1_g_x;
  creal_T c1_twid;
  int32_T c1_c_i;
  int32_T c1_e_a;
  int32_T c1_b_b;
  int32_T c1_f_a;
  int32_T c1_c_b;
  int32_T c1_g_a;
  int32_T c1_h_a;
  int32_T c1_d_b;
  int32_T c1_i_a;
  int32_T c1_d_i;
  uint32_T c1_ui;
  uint32_T c1_u0;
  int32_T c1_i8;
  for(c1_i5 = 0; c1_i5 < 1024; c1_i5 = c1_i5 + 1) {
    c1_b_x[c1_i5].re = c1_x[c1_i5].re;
    c1_b_x[c1_i5].im = c1_x[c1_i5].im;
  }
  for(c1_i6 = 0; c1_i6 < 1024; c1_i6 = c1_i6 + 1) {
    c1_c_x[c1_i6].re = c1_b_x[c1_i6].re;
    c1_c_x[c1_i6].im = c1_b_x[c1_i6].im;
  }
  for(c1_i7 = 0; c1_i7 < 1024; c1_i7 = c1_i7 + 1) {
    c1_b_y[c1_i7].re = 0.0;
    c1_b_y[c1_i7].im = 0.0;
  }
  c1_ix = 1;
  c1_j = 0;
  c1_iy = 1;
  for(c1_i = 1; c1_i < 1024; c1_i = c1_i + 1) {
    c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("iy",
      (real_T)c1_iy), 1, 1024, 1) - 1].re = c1_c_x[
      _SFD_EML_ARRAY_BOUNDS_CHECK("x", _SFD_INTEGER_CHECK("ix", (real_T)c1_ix),
     1, 1024, 1) - 1].re;
    c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("iy",
      (real_T)c1_iy), 1, 1024, 1) - 1].im = c1_c_x[
      _SFD_EML_ARRAY_BOUNDS_CHECK("x", _SFD_INTEGER_CHECK("ix", (real_T)c1_ix),
     1, 1024, 1) - 1].im;
    c1_b_j = c1_j;
    c1_j = c1_b_j;
    c1_nu = 1024U;
    c1_ju = (uint32_T)c1_j;
    for(c1_tst = 1U; c1_tst; c1_tst = ((real_T)(c1_ju & c1_nu) == 0.0)) {
      c1_nu = c1_nu >> 1U;
      c1_ju = c1_ju ^ c1_nu;
    }
    c1_j = (int32_T)c1_ju;
    c1_b = c1_j;
    c1_iy = 1 + c1_b;
    c1_a = c1_ix;
    c1_ix = c1_a + 1;
  }
  c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("iy",
    (real_T)c1_iy), 1, 1024, 1) - 1].re = c1_c_x[
    _SFD_EML_ARRAY_BOUNDS_CHECK("x", _SFD_INTEGER_CHECK("ix", (real_T)c1_ix), 1,
   1024, 1) - 1].re;
  c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("iy",
    (real_T)c1_iy), 1, 1024, 1) - 1].im = c1_c_x[
    _SFD_EML_ARRAY_BOUNDS_CHECK("x", _SFD_INTEGER_CHECK("ix", (real_T)c1_ix), 1,
   1024, 1) - 1].im;
  c1_i1 = 1;
  for(c1_b_i = 0; c1_b_i < 1023; c1_b_i = c1_b_i + 2) {
    c1_b_a = c1_i1;
    c1_i2 = c1_b_a + 1;
    c1_temp.re = c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y",
     _SFD_INTEGER_CHECK("i2", (real_T)c1_i2), 1, 1024, 1) - 1].re;
    c1_temp.im = c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y",
     _SFD_INTEGER_CHECK("i2", (real_T)c1_i2), 1, 1024, 1) - 1].im;
    c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i2",
      (real_T)c1_i2), 1, 1024, 1) - 1].re = c1_b_y[
      _SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1", (real_T)c1_i1),
     1, 1024, 1) - 1].re - c1_temp.re;
    c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i2",
      (real_T)c1_i2), 1, 1024, 1) - 1].im = c1_b_y[
      _SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1", (real_T)c1_i1),
     1, 1024, 1) - 1].im - c1_temp.im;
    c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1",
      (real_T)c1_i1), 1, 1024, 1) - 1].re = c1_b_y[
      _SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1", (real_T)c1_i1),
     1, 1024, 1) - 1].re + c1_temp.re;
    c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1",
      (real_T)c1_i1), 1, 1024, 1) - 1].im = c1_b_y[
      _SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1", (real_T)c1_i1),
     1, 1024, 1) - 1].im + c1_temp.im;
    c1_c_a = c1_i2;
    c1_i1 = c1_c_a + 1;
  }
  c1_iDelta = 2;
  for(c1_k = 256; (real_T)c1_k > 0.0; c1_k = c1_i8) {
    c1_istart = 0;
    for(c1_j = 0; c1_j < 512; c1_j = c1_h_a + c1_d_b) {
      c1_d_a = c1_istart;
      c1_i1 = c1_d_a + 1;
      c1_theta = (real_T)c1_j * -6.1359231515425647E-003;
      c1_d_x = c1_theta;
      c1_e_x = c1_d_x;
      c1_e_x = sin(c1_e_x);
      c1_f_x = c1_theta;
      c1_g_x = c1_f_x;
      c1_g_x = cos(c1_g_x);
      c1_twid.re = c1_g_x;
      c1_twid.im = c1_e_x;
      for(c1_c_i = 1; c1_c_i <= c1_k; c1_c_i = c1_c_i + 1) {
        c1_e_a = c1_i1;
        c1_b_b = c1_iDelta;
        c1_i2 = c1_e_a + c1_b_b;
        c1_temp.re = c1_twid.re * c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y",
         _SFD_INTEGER_CHECK("i2", (real_T)c1_i2), 1, 1024, 1) - 1].re -
        c1_twid.im * c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y",
         _SFD_INTEGER_CHECK("i2", (real_T)c1_i2), 1, 1024, 1) - 1].im;
        c1_temp.im = c1_twid.re * c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y",
         _SFD_INTEGER_CHECK("i2", (real_T)c1_i2), 1, 1024, 1) - 1].im +
        c1_twid.im * c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y",
         _SFD_INTEGER_CHECK("i2", (real_T)c1_i2), 1, 1024, 1) - 1].re;
        c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i2",
          (real_T)c1_i2), 1, 1024, 1) - 1].re = c1_b_y[
          _SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1",
          (real_T)c1_i1), 1, 1024, 1) - 1].re - c1_temp.re;
        c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i2",
          (real_T)c1_i2), 1, 1024, 1) - 1].im = c1_b_y[
          _SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1",
          (real_T)c1_i1), 1, 1024, 1) - 1].im - c1_temp.im;
        c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1",
          (real_T)c1_i1), 1, 1024, 1) - 1].re = c1_b_y[
          _SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1",
          (real_T)c1_i1), 1, 1024, 1) - 1].re + c1_temp.re;
        c1_b_y[_SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1",
          (real_T)c1_i1), 1, 1024, 1) - 1].im = c1_b_y[
          _SFD_EML_ARRAY_BOUNDS_CHECK("y", _SFD_INTEGER_CHECK("i1",
          (real_T)c1_i1), 1, 1024, 1) - 1].im + c1_temp.im;
        c1_f_a = c1_i2;
        c1_c_b = c1_iDelta;
        c1_i1 = c1_f_a + c1_c_b;
      }
      c1_g_a = c1_istart;
      c1_istart = c1_g_a + 1;
      c1_h_a = c1_j;
      c1_d_b = c1_k;
    }
    c1_i_a = c1_iDelta;
    c1_iDelta = c1_i_a * 2;
    c1_d_i = c1_k;
    c1_k = c1_d_i;
    c1_ui = (uint32_T)c1_k;
    c1_u0 = c1_ui >> 1U;
    if(c1_u0 > 2147483647U) {
      c1_i8 = MAX_int32_T;
    } else {
      c1_i8 = (int32_T)c1_u0;
    }
  }
}

static real_T c1_abs(creal_T c1_x)
{
  real_T c1_x1;
  real_T c1_x2;
  real_T c1_a;
  real_T c1_b;
  real_T c1_b_x;
  real_T c1_c_y;
  real_T c1_c_x;
  real_T c1_d_y;
  c1_x1 = c1_x.re;
  c1_x2 = c1_x.im;
  c1_a = fabs(c1_x1);
  c1_b = fabs(c1_x2);
  if(c1_a == 0.0) {
    return c1_b;
  } else if(c1_b == 0.0) {
    return c1_a;
  } else if(c1_a == c1_b) {
    return c1_a * 1.4142135623730951E+000;
  } else if(c1_b > c1_a) {
    c1_b_x = c1_a;
    c1_c_y = c1_b;
    c1_a = c1_b_x / c1_c_y;
    return c1_b * sqrt(1.0 + c1_a * c1_a);
  } else {
    c1_c_x = c1_b;
    c1_d_y = c1_a;
    c1_b = c1_c_x / c1_d_y;
    return c1_a * sqrt(1.0 + c1_b * c1_b);
  }
}

static real_T c1_mpower(real_T c1_a)