EMS/1.Software/Verify/simulink/fuc_ert_rtw/fuc.c

/*
 * File: fuc.c
 *
 * Code generated for Simulink model 'fuc'.
 *
 * Model version                  : 1.18
 * Simulink Coder version         : 9.8 (R2022b) 13-May-2022
 * C/C++ source code generated on : Sat Jan  6 10:24:46 2024
 *
 * Target selection: ert.tlc
 * Embedded hardware selection: ARM Compatible->ARM 64-bit (LP64)
 * Code generation objectives: Unspecified
 * Validation result: Not run
 */

#include "fuc.h"
#include "rtwtypes.h"
#include <math.h>
#include "fuc_private.h"
#include "rt_nonfinite.h"

/* Block signals (default storage) */
B_fuc_T fuc_B;

/* Continuous states */
X_fuc_T fuc_X;

/* Real-time model */
static RT_MODEL_fuc_T fuc_M_;
RT_MODEL_fuc_T *const fuc_M = &fuc_M_;

/*
 * This function updates continuous states using the ODE3 fixed-step
 * solver algorithm
 */
static void rt_ertODEUpdateContinuousStates(RTWSolverInfo *si )
{
  /* Solver Matrices */
  static const real_T rt_ODE3_A[3] = {
    1.0/2.0, 3.0/4.0, 1.0
  };

  static const real_T rt_ODE3_B[3][3] = {
    { 1.0/2.0, 0.0, 0.0 },

    { 0.0, 3.0/4.0, 0.0 },

    { 2.0/9.0, 1.0/3.0, 4.0/9.0 }
  };

  time_T t = rtsiGetT(si);
  time_T tnew = rtsiGetSolverStopTime(si);
  time_T h = rtsiGetStepSize(si);
  real_T *x = rtsiGetContStates(si);
  ODE3_IntgData *id = (ODE3_IntgData *)rtsiGetSolverData(si);
  real_T *y = id->y;
  real_T *f0 = id->f[0];
  real_T *f1 = id->f[1];
  real_T *f2 = id->f[2];
  real_T hB[3];
  int_T i;
  int_T nXc = 3;
  rtsiSetSimTimeStep(si,MINOR_TIME_STEP);

  /* Save the state values at time t in y, we'll use x as ynew. */
  (void) memcpy(y, x,
                (uint_T)nXc*sizeof(real_T));

  /* Assumes that rtsiSetT and ModelOutputs are up-to-date */
  /* f0 = f(t,y) */
  rtsiSetdX(si, f0);
  fuc_derivatives();

  /* f(:,2) = feval(odefile, t + hA(1), y + f*hB(:,1), args(:)(*)); */
  hB[0] = h * rt_ODE3_B[0][0];
  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (f0[i]*hB[0]);
  }

  rtsiSetT(si, t + h*rt_ODE3_A[0]);
  rtsiSetdX(si, f1);
  fuc_step();
  fuc_derivatives();

  /* f(:,3) = feval(odefile, t + hA(2), y + f*hB(:,2), args(:)(*)); */
  for (i = 0; i <= 1; i++) {
    hB[i] = h * rt_ODE3_B[1][i];
  }

  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (f0[i]*hB[0] + f1[i]*hB[1]);
  }

  rtsiSetT(si, t + h*rt_ODE3_A[1]);
  rtsiSetdX(si, f2);
  fuc_step();
  fuc_derivatives();

  /* tnew = t + hA(3);
     ynew = y + f*hB(:,3); */
  for (i = 0; i <= 2; i++) {
    hB[i] = h * rt_ODE3_B[2][i];
  }

  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (f0[i]*hB[0] + f1[i]*hB[1] + f2[i]*hB[2]);
  }

  rtsiSetT(si, tnew);
  rtsiSetSimTimeStep(si,MAJOR_TIME_STEP);
}

real_T rt_powd_snf(real_T u0, real_T u1)
{
  real_T y;
  if (rtIsNaN(u0) || rtIsNaN(u1)) {
    y = (rtNaN);
  } else {
    real_T tmp;
    real_T tmp_0;
    tmp = fabs(u0);
    tmp_0 = fabs(u1);
    if (rtIsInf(u1)) {
      if (tmp == 1.0) {
        y = 1.0;
      } else if (tmp > 1.0) {
        if (u1 > 0.0) {
          y = (rtInf);
        } else {
          y = 0.0;
        }
      } else if (u1 > 0.0) {
        y = 0.0;
      } else {
        y = (rtInf);
      }
    } else if (tmp_0 == 0.0) {
      y = 1.0;
    } else if (tmp_0 == 1.0) {
      if (u1 > 0.0) {
        y = u0;
      } else {
        y = 1.0 / u0;
      }
    } else if (u1 == 2.0) {
      y = u0 * u0;
    } else if ((u1 == 0.5) && (u0 >= 0.0)) {
      y = sqrt(u0);
    } else if ((u0 < 0.0) && (u1 > floor(u1))) {
      y = (rtNaN);
    } else {
      y = pow(u0, u1);
    }
  }

  return y;
}

/* Model step function */
void fuc_step(void)
{
  real_T rtb_Sum;
  real_T rtb_Sum_tmp;
  real_T rtb_y;
  real_T rtb_y_c;
  real_T y_j_tmp;
  if (rtmIsMajorTimeStep(fuc_M)) {
    /* set solver stop time */
    rtsiSetSolverStopTime(&fuc_M->solverInfo,((fuc_M->Timing.clockTick0+1)*
      fuc_M->Timing.stepSize0));
  }                                    /* end MajorTimeStep */

  /* Update absolute time of base rate at minor time step */
  if (rtmIsMinorTimeStep(fuc_M)) {
    fuc_M->Timing.t[0] = rtsiGetT(&fuc_M->solverInfo);
  }

  /* Clock: '<S2>/t' */
  rtb_y = fuc_M->Timing.t[0];

  /* MATLAB Function: '<S2>/sint' incorporates:
   *  Clock: '<S2>/t'
   *  MATLAB Function: '<S2>/ddsint'
   *  SignalConversion generated from: '<S8>/ SFunction '
   */
  rtb_Sum_tmp = sin(0.20943951023931953 * rtb_y);

  /* Sum: '<Root>/Sum' incorporates:
   *  Integrator: '<Root>/sys'
   *  MATLAB Function: '<S2>/sint'
   *  SignalConversion generated from: '<S8>/ SFunction '
   */
  rtb_Sum = rtb_Sum_tmp * 0.0 - fuc_X.sys_CSTATE;

  /* MATLAB Function: '<S2>/dsint' incorporates:
   *  Clock: '<S2>/t'
   *  SignalConversion generated from: '<S7>/ SFunction '
   */
  rtb_y_c = cos(0.20943951023931953 * rtb_y) * 0.0;

  /* Integrator: '<Root>/Integrator' */
  fuc_B.x2 = fuc_X.Integrator_CSTATE;

  /* MATLAB Function: '<Root>/u(2)+u(1)*u(3)-u(4)' incorporates:
   *  SignalConversion generated from: '<S5>/ SFunction '
   */
  rtb_y = (rtb_y_c + rtb_Sum) - fuc_B.x2;

  /* MATLAB Function: '<Root>/u' incorporates:
   *  Integrator: '<Root>/sys'
   *  MATLAB Function: '<Root>/-u(3)//u(2)*u(1)^3+u(4)//u(2)'
   *  MATLAB Function: '<Root>/u(1)//u(3)*u(2)^3'
   */
  y_j_tmp = rt_powd_snf(fuc_X.sys_CSTATE, 3.0);

  /* MATLAB Function: '<Root>/-u(3)//u(2)*u(1)^3+u(4)//u(2)' incorporates:
   *  Integrator: '<Root>/Integrator1'
   *  MATLAB Function: '<Root>/u'
   *  MATLAB Function: '<S2>/ddsint'
   *  SignalConversion generated from: '<S3>/ SFunction '
   *  SignalConversion generated from: '<S6>/ SFunction '
   */
  fuc_B.y_j = ((((rtb_Sum_tmp * -0.0 + rtb_Sum) + (rtb_y_c - fuc_B.x2)) +
                fuc_X.Integrator1_CSTATE * y_j_tmp) + rtb_y) - y_j_tmp;

  /* MATLAB Function: '<Root>/u(1)//u(3)*u(2)^3' incorporates:
   *  SignalConversion generated from: '<S4>/ SFunction '
   */
  fuc_B.y = rtb_y * y_j_tmp;
  if (rtmIsMajorTimeStep(fuc_M)) {
    rt_ertODEUpdateContinuousStates(&fuc_M->solverInfo);

    /* Update absolute time for base rate */
    /* The "clockTick0" counts the number of times the code of this task has
     * been executed. The absolute time is the multiplication of "clockTick0"
     * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not
     * overflow during the application lifespan selected.
     */
    ++fuc_M->Timing.clockTick0;
    fuc_M->Timing.t[0] = rtsiGetSolverStopTime(&fuc_M->solverInfo);

    {
      /* Update absolute timer for sample time: [10.0s, 0.0s] */
      /* The "clockTick1" counts the number of times the code of this task has
       * been executed. The resolution of this integer timer is 10.0, which is the step size
       * of the task. Size of "clockTick1" ensures timer will not overflow during the
       * application lifespan selected.
       */
      fuc_M->Timing.clockTick1++;
    }
  }                                    /* end MajorTimeStep */
}

/* Derivatives for root system: '<Root>' */
void fuc_derivatives(void)
{
  XDot_fuc_T *_rtXdot;
  _rtXdot = ((XDot_fuc_T *) fuc_M->derivs);

  /* Derivatives for Integrator: '<Root>/sys' */
  _rtXdot->sys_CSTATE = fuc_B.x2;

  /* Derivatives for Integrator: '<Root>/Integrator' */
  _rtXdot->Integrator_CSTATE = fuc_B.y_j;

  /* Derivatives for Integrator: '<Root>/Integrator1' */
  _rtXdot->Integrator1_CSTATE = fuc_B.y;
}

/* Model initialize function */
void fuc_initialize(void)
{
  /* Registration code */

  /* initialize non-finites */
  rt_InitInfAndNaN(sizeof(real_T));

  {
    /* Setup solver object */
    rtsiSetSimTimeStepPtr(&fuc_M->solverInfo, &fuc_M->Timing.simTimeStep);
    rtsiSetTPtr(&fuc_M->solverInfo, &rtmGetTPtr(fuc_M));
    rtsiSetStepSizePtr(&fuc_M->solverInfo, &fuc_M->Timing.stepSize0);
    rtsiSetdXPtr(&fuc_M->solverInfo, &fuc_M->derivs);
    rtsiSetContStatesPtr(&fuc_M->solverInfo, (real_T **) &fuc_M->contStates);
    rtsiSetNumContStatesPtr(&fuc_M->solverInfo, &fuc_M->Sizes.numContStates);
    rtsiSetNumPeriodicContStatesPtr(&fuc_M->solverInfo,
      &fuc_M->Sizes.numPeriodicContStates);
    rtsiSetPeriodicContStateIndicesPtr(&fuc_M->solverInfo,
      &fuc_M->periodicContStateIndices);
    rtsiSetPeriodicContStateRangesPtr(&fuc_M->solverInfo,
      &fuc_M->periodicContStateRanges);
    rtsiSetErrorStatusPtr(&fuc_M->solverInfo, (&rtmGetErrorStatus(fuc_M)));
    rtsiSetRTModelPtr(&fuc_M->solverInfo, fuc_M);
  }

  rtsiSetSimTimeStep(&fuc_M->solverInfo, MAJOR_TIME_STEP);
  fuc_M->intgData.y = fuc_M->odeY;
  fuc_M->intgData.f[0] = fuc_M->odeF[0];
  fuc_M->intgData.f[1] = fuc_M->odeF[1];
  fuc_M->intgData.f[2] = fuc_M->odeF[2];
  fuc_M->contStates = ((X_fuc_T *) &fuc_X);
  rtsiSetSolverData(&fuc_M->solverInfo, (void *)&fuc_M->intgData);
  rtsiSetIsMinorTimeStepWithModeChange(&fuc_M->solverInfo, false);
  rtsiSetSolverName(&fuc_M->solverInfo,"ode3");
  rtmSetTPtr(fuc_M, &fuc_M->Timing.tArray[0]);
  fuc_M->Timing.stepSize0 = 10.0;

  /* InitializeConditions for Integrator: '<Root>/sys' */
  fuc_X.sys_CSTATE = 0.0;

  /* InitializeConditions for Integrator: '<Root>/Integrator' */
  fuc_X.Integrator_CSTATE = 0.0;

  /* InitializeConditions for Integrator: '<Root>/Integrator1' */
  fuc_X.Integrator1_CSTATE = 0.0;
}

/* Model terminate function */
void fuc_terminate(void)
{
  /* (no terminate code required) */
}

/*
 * File trailer for generated code.
 *
 * [EOF]
 */