RadarSim/SigGen/Radar201/RadarSignalGenerator201.cpp

//
// Academic License - for use in teaching, academic research, and meeting
// course requirements at degree granting institutions only.  Not for
// government, commercial, or other organizational use.
// File: RadarSignalGenerator201.cpp
//
// MATLAB Coder version            : 5.3
// C/C++ source code generated on  : 26-Apr-2023 23:47:33
//

// Include Files
#include "RadarSignalGenerator201.h"
#include "AbstractPhaseCodedWaveform201.h"
#include "PhaseCodedWaveform201.h"
#include "../rt_nonfinite.h"
#include "../coder_array.h"
#include <cmath>

// Function Declarations
static void times(coder::array<creal_T, 1U> &xt,
                  const coder::array<creal_T, 1U> &r);

// Function Definitions
//
// Arguments    : coder::array<creal_T, 1U> &xt
//                const coder::array<creal_T, 1U> &r
// Return Type  : void
//
static void times(coder::array<creal_T, 1U> &xt,
                  const coder::array<creal_T, 1U> &r)
{
  coder::array<creal_T, 1U> b_xt;
  int i;
  int loop_ub;
  int stride_0_0;
  int stride_1_0;
  if (r.size(0) == 1) {
    i = xt.size(0);
  } else {
    i = r.size(0);
  }
  b_xt.set_size(i);
  stride_0_0 = (xt.size(0) != 1);
  stride_1_0 = (r.size(0) != 1);
  if (r.size(0) == 1) {
    loop_ub = xt.size(0);
  } else {
    loop_ub = r.size(0);
  }
  for (i = 0; i < loop_ub; i++) {
    double d;
    double d1;
    int i1;
    i1 = i * stride_1_0;
    d = r[i1].im;
    d1 = r[i1].re;
    b_xt[i].re = xt[i * stride_0_0].re * d1 - xt[i * stride_0_0].im * d;
    b_xt[i].im = xt[i * stride_0_0].re * d + xt[i * stride_0_0].im * d1;
  }
  xt.set_size(b_xt.size(0));
  loop_ub = b_xt.size(0);
  for (i = 0; i < loop_ub; i++) {
    xt[i] = b_xt[i];
  }
}

//
// RADARSIGNALGENERATOR1 此处显示有关此函数的摘要
//    此处显示详细说明
//
// Arguments    : coder::array<double, 1U> &sig
//                double *fs
//                double PRF[3]
//                double *len
// Return Type  : void
//
void RadarSignalGenerator201(coder::array<double, 1U> &sig, double *fs,
                             double PRF[3], double *len)
{
  static creal_T dcv[20000];
  coder::phased::PhaseCodedWaveform201 wavGen;
  coder::array<creal_T, 1U> r1;
  coder::array<creal_T, 1U> xt;
  coder::array<double, 2U> r;
  coder::array<double, 1U> b_xt;
  double idx;
  int ii;
  int k;
  int mode;
  int ndbl;
  PRF[0] = 500000.0;
  PRF[1] = 333333.33333333331;
  PRF[2] = 250000.0;
  //      simTime = 2e-5;
  wavGen.isInitialized = 0;
  wavGen.matlabCodegenIsDeleted = false;
  //  连续调频波定义
  //  产生5个脉冲
  //      numPulses = fix(simTime*PRF);
  *len = 0.0;
  for (ii = 0; ii < 5; ii++) {
    mode = static_cast<int>(std::fmod(static_cast<double>(ii) + 1.0, 3.0));
    if (mode == 0) {
      mode = 3;
    }
    *len += 2.0E+10 / PRF[mode - 1];
  }
  ndbl = static_cast<int>(*len);
  sig.set_size(ndbl);
  for (k = 0; k < ndbl; k++) {
    sig[k] = 0.0;
  }
  idx = 1.0;
  for (ii = 0; ii < 5; ii++) {
    double OutputPulseIndex_idx_0;
    double cdiff;
    double kd;
    int nm1d2;
    mode = static_cast<int>(std::fmod(static_cast<double>(ii) + 1.0, 3.0));
    if (mode == 0) {
      mode = 3;
    }
    //  迭代波形
    if (wavGen.isInitialized != 1) {
      wavGen.isInitialized = 1;
      wavGen.isSetupComplete = true;
      wavGen.TunablePropsChanged = false;
      wavGen.pOutputStartPulseIndex = 1.0;
      wavGen.pOutputPulseInterval[0] = 0.0;
      wavGen.pOutputPulseInterval[1] = 1.0;
    }
    if (wavGen.TunablePropsChanged) {
      wavGen.TunablePropsChanged = false;
    }
    kd = (wavGen.pOutputStartPulseIndex + wavGen.pOutputPulseInterval[0]) - 1.0;
    if (std::isnan(kd) || std::isinf(kd)) {
      cdiff = rtNaN;
    } else if (kd == 0.0) {
      cdiff = 0.0;
    } else {
      cdiff = std::fmod(kd, 3.0);
      if (cdiff == 0.0) {
        cdiff = 0.0;
      } else if (kd < 0.0) {
        cdiff += 3.0;
      }
    }
    OutputPulseIndex_idx_0 = cdiff + 1.0;
    kd = (wavGen.pOutputStartPulseIndex + wavGen.pOutputPulseInterval[1]) - 1.0;
    if (std::isnan(kd) || std::isinf(kd)) {
      cdiff = rtNaN;
    } else if (kd == 0.0) {
      cdiff = 0.0;
    } else {
      cdiff = std::fmod(kd, 3.0);
      if (cdiff == 0.0) {
        cdiff = 0.0;
      } else if (kd < 0.0) {
        cdiff += 3.0;
      }
    }
    wavGen.pOutputStartPulseIndex = cdiff + 1.0;
    ndbl = 20000 * (static_cast<int>(OutputPulseIndex_idx_0) - 1);
    xt.set_size(ndbl + 40000);
    for (k = 0; k <= ndbl + 39999; k++) {
      xt[k].re = 0.0;
      xt[k].im = 0.0;
    }
    coder::phased::AbstractPhaseCodedWaveform201::getMatchingWaveform(dcv);
    for (k = 0; k < 20000; k++) {
      xt[k] = dcv[k];
    }
    //  载波调制
    kd = (static_cast<double>(xt.size(0)) - 1.0) / 2.0E+10;
    ndbl = static_cast<int>(std::floor(kd / 5.0E-11 + 0.5));
    OutputPulseIndex_idx_0 = static_cast<double>(ndbl) * 5.0E-11;
    cdiff = OutputPulseIndex_idx_0 - kd;
    if (std::abs(cdiff) < 4.4408920985006262E-16 * std::abs(kd)) {
      ndbl++;
      OutputPulseIndex_idx_0 = kd;
    } else if (cdiff > 0.0) {
      OutputPulseIndex_idx_0 = (static_cast<double>(ndbl) - 1.0) * 5.0E-11;
    } else {
      ndbl++;
    }
    r.set_size(1, ndbl);
    r[0] = 0.0;
    r[ndbl - 1] = OutputPulseIndex_idx_0;
    nm1d2 = (ndbl - 1) / 2;
    for (k = 0; k <= nm1d2 - 2; k++) {
      kd = (static_cast<double>(k) + 1.0) * 5.0E-11;
      r[k + 1] = kd;
      r[(ndbl - k) - 2] = OutputPulseIndex_idx_0 - kd;
    }
    if (nm1d2 << 1 == ndbl - 1) {
      r[nm1d2] = OutputPulseIndex_idx_0 / 2.0;
    } else {
      kd = static_cast<double>(nm1d2) * 5.0E-11;
      r[nm1d2] = kd;
      r[nm1d2 + 1] = OutputPulseIndex_idx_0 - kd;
    }
    r1.set_size(r.size(1));
    ndbl = r.size(1);
    for (k = 0; k < ndbl; k++) {
      r1[k].re = r[k] * 0.0;
      r1[k].im = r[k] * 5.969026041820607E+10;
    }
    ndbl = r1.size(0);
    for (k = 0; k < ndbl; k++) {
      if (r1[k].im == 0.0) {
        r1[k].re = std::exp(r1[k].re);
        r1[k].im = 0.0;
      } else if (std::isinf(r1[k].im) && std::isinf(r1[k].re) &&
                 (r1[k].re < 0.0)) {
        r1[k].re = 0.0;
        r1[k].im = 0.0;
      } else {
        cdiff = std::exp(r1[k].re / 2.0);
        r1[k].re = cdiff * (cdiff * std::cos(r1[k].im));
        r1[k].im = cdiff * (cdiff * std::sin(r1[k].im));
      }
    }
    if (xt.size(0) == r1.size(0)) {
      ndbl = xt.size(0);
      for (k = 0; k < ndbl; k++) {
        double re_tmp;
        kd = xt[k].re;
        OutputPulseIndex_idx_0 = r1[k].im;
        cdiff = xt[k].im;
        re_tmp = r1[k].re;
        xt[k].re = kd * re_tmp - cdiff * OutputPulseIndex_idx_0;
        xt[k].im = kd * OutputPulseIndex_idx_0 + cdiff * re_tmp;
      }
    } else {
      times(xt, r1);
    }
    kd = idx + 2.0E+10 / PRF[mode - 1];
    if (idx > kd - 1.0) {
      k = -1;
      nm1d2 = 0;
    } else {
      k = static_cast<int>(idx) - 2;
      nm1d2 = static_cast<int>(kd - 1.0);
    }
    b_xt.set_size(xt.size(0));
    ndbl = xt.size(0);
    for (mode = 0; mode < ndbl; mode++) {
      b_xt[mode] = xt[mode].re;
    }
    ndbl = (nm1d2 - k) - 1;
    for (nm1d2 = 0; nm1d2 < ndbl; nm1d2++) {
      sig[(k + nm1d2) + 1] = b_xt[nm1d2];
    }
    idx = kd;
  }
  wavGen.matlabCodegenDestructor();
  *fs = 2.0E+10;
}

//
// File trailer for RadarSignalGenerator201.cpp
//
// [EOF]
//