/*

 * Arduino_skal.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.

 *

 * Code generation for model "Arduino_skal".

 *

 * Model version              : 1.1

 * Simulink Coder version : 9.5 (R2021a) 14-Nov-2020

 * C++ source code generated on : Thu Apr 15 15:56:50 2021

 *

 * Target selection: grt.tlc

 * Note: GRT includes extra infrastructure and instrumentation for prototyping

 * Embedded hardware selection: Intel->x86-64 (Windows64)

 * Code generation objective: Debugging

 * Validation result: Not run

 */



#include "Arduino_skal.h"

#include "Arduino_skal_private.h"



/*

 * This function updates continuous states using the ODE3 fixed-step

 * solver algorithm

 */

void Arduino_skalModelClass::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 = static_cast<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 = 4;

  rtsiSetSimTimeStep(si,MINOR_TIME_STEP);



  /* Save the state values at time t in y, we'll use x as ynew. */

  (void) std::memcpy(y, x,

                     static_cast<uint_T>(nXc)*sizeof(real_T));



  /* Assumes that rtsiSetT and ModelOutputs are up-to-date */

  /* f0 = f(t,y) */

  rtsiSetdX(si, f0);

  Arduino_skal_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);

  this->step();

  Arduino_skal_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);

  this->step();

  Arduino_skal_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);

}



/* Model step function */

void Arduino_skalModelClass::step()

{

  const real_T *tmp_3;

  real_T currentTime;

  real_T tmp;

  real_T tmp_0;

  real_T tmp_1;

  real_T tmp_2;

  real_T u0;

  int32_T i;

  int32_T i_0;

  if (rtmIsMajorTimeStep((&Arduino_skal_M))) {

    /* set solver stop time */

    if (!((&Arduino_skal_M)->Timing.clockTick0+1)) {

      rtsiSetSolverStopTime(&(&Arduino_skal_M)->solverInfo, (((&Arduino_skal_M

        )->Timing.clockTickH0 + 1) * (&Arduino_skal_M)->Timing.stepSize0 *

        4294967296.0));

    } else {

      rtsiSetSolverStopTime(&(&Arduino_skal_M)->solverInfo, (((&Arduino_skal_M

        )->Timing.clockTick0 + 1) * (&Arduino_skal_M)->Timing.stepSize0 +

        (&Arduino_skal_M)->Timing.clockTickH0 * (&Arduino_skal_M)

        ->Timing.stepSize0 * 4294967296.0));

    }

  }                                    /* end MajorTimeStep */



  /* Update absolute time of base rate at minor time step */

  if (rtmIsMinorTimeStep((&Arduino_skal_M))) {

    (&Arduino_skal_M)->Timing.t[0] = rtsiGetT(&(&Arduino_skal_M)->solverInfo);

  }



  if (rtmIsMajorTimeStep((&Arduino_skal_M))) {

    /* Constant: '<S1>/X0' */

    Arduino_skal_B.X0[0] = Arduino_skal_P.X0_Value[0];

    Arduino_skal_B.X0[1] = Arduino_skal_P.X0_Value[1];

    Arduino_skal_B.X0[2] = Arduino_skal_P.X0_Value[2];

    Arduino_skal_B.X0[3] = Arduino_skal_P.X0_Value[3];

  }



  /* Integrator: '<S1>/MemoryX' */

  if (Arduino_skal_DW.MemoryX_IWORK != 0) {

    Arduino_skal_X.MemoryX_CSTATE[0] = Arduino_skal_B.X0[0];

    Arduino_skal_X.MemoryX_CSTATE[1] = Arduino_skal_B.X0[1];

    Arduino_skal_X.MemoryX_CSTATE[2] = Arduino_skal_B.X0[2];

    Arduino_skal_X.MemoryX_CSTATE[3] = Arduino_skal_B.X0[3];

  }



  /* Integrator: '<S1>/MemoryX' */

  Arduino_skal_B.MemoryX[0] = Arduino_skal_X.MemoryX_CSTATE[0];



  /* Gain: '<Root>/Gain' */

  u0 = Arduino_skal_P.K[0] * Arduino_skal_B.MemoryX[0];



  /* Integrator: '<S1>/MemoryX' */

  Arduino_skal_B.MemoryX[1] = Arduino_skal_X.MemoryX_CSTATE[1];



  /* Gain: '<Root>/Gain' */

  u0 += Arduino_skal_P.K[1] * Arduino_skal_B.MemoryX[1];



  /* Integrator: '<S1>/MemoryX' */

  Arduino_skal_B.MemoryX[2] = Arduino_skal_X.MemoryX_CSTATE[2];



  /* Gain: '<Root>/Gain' */

  u0 += Arduino_skal_P.K[2] * Arduino_skal_B.MemoryX[2];



  /* Integrator: '<S1>/MemoryX' */

  Arduino_skal_B.MemoryX[3] = Arduino_skal_X.MemoryX_CSTATE[3];



  /* Gain: '<Root>/Gain' */

  u0 += Arduino_skal_P.K[3] * Arduino_skal_B.MemoryX[3];



  /* Gain: '<Root>/Gain' */

  Arduino_skal_B.Gain = u0;

  if (rtmIsMajorTimeStep((&Arduino_skal_M))) {

    /* MATLAB Function: '<S51>/SqrtUsedFcn' incorporates:

     *  Constant: '<S2>/CovarianceZ'

     *  Constant: '<S51>/isSqrtUsed'

     */

    /* :  if isSqrtUsed */

    if (Arduino_skal_P.isSqrtUsed_Value) {

      /* :  P = u*u.'; */

      for (i = 0; i < 4; i++) {

        for (i_0 = 0; i_0 < 4; i_0++) {

          Arduino_skal_B.P[i_0 + (i << 2)] = 0.0;

          Arduino_skal_B.P[i_0 + (i << 2)] +=

            Arduino_skal_P.CovarianceZ_Value[i_0] *

            Arduino_skal_P.CovarianceZ_Value[i];

          Arduino_skal_B.P[i_0 + (i << 2)] +=

            Arduino_skal_P.CovarianceZ_Value[i_0 + 4] *

            Arduino_skal_P.CovarianceZ_Value[i + 4];

          Arduino_skal_B.P[i_0 + (i << 2)] +=

            Arduino_skal_P.CovarianceZ_Value[i_0 + 8] *

            Arduino_skal_P.CovarianceZ_Value[i + 8];

          Arduino_skal_B.P[i_0 + (i << 2)] +=

            Arduino_skal_P.CovarianceZ_Value[i_0 + 12] *

            Arduino_skal_P.CovarianceZ_Value[i + 12];

        }

      }

    } else {

      /* :  else */

      /* :  P = u; */

      std::memcpy(&Arduino_skal_B.P[0], &Arduino_skal_P.CovarianceZ_Value[0],

                  sizeof(real_T) << 4U);

    }



    /* End of MATLAB Function: '<S51>/SqrtUsedFcn' */

  }



  /* Product: '<S22>/A[k]*xhat[k|k-1]' incorporates:

   *  Constant: '<S1>/A'

   */

  tmp_3 = &Arduino_skal_P.A_Value[0];

  tmp = Arduino_skal_B.MemoryX[0];

  tmp_0 = Arduino_skal_B.MemoryX[1];

  tmp_1 = Arduino_skal_B.MemoryX[2];

  tmp_2 = Arduino_skal_B.MemoryX[3];

  for (i = 0; i < 4; i++) {

    u0 = tmp_3[i] * tmp;

    u0 += tmp_3[i + 4] * tmp_0;

    u0 += tmp_3[i + 8] * tmp_1;

    u0 += tmp_3[i + 12] * tmp_2;



    /* Product: '<S22>/A[k]*xhat[k|k-1]' */

    Arduino_skal_B.Akxhatkk1[i] = u0;

  }



  /* End of Product: '<S22>/A[k]*xhat[k|k-1]' */



  /* Step: '<Root>/Step' */

  currentTime = (&Arduino_skal_M)->Timing.t[0];

  if (currentTime < Arduino_skal_P.Step_Time) {

    /* Step: '<Root>/Step' */

    Arduino_skal_B.Step = Arduino_skal_P.Step_Y0;

  } else {

    /* Step: '<Root>/Step' */

    Arduino_skal_B.Step = Arduino_skal_P.Step_YFinal;

  }



  /* End of Step: '<Root>/Step' */



  /* Gain: '<Root>/Kr' */

  Arduino_skal_B.Kr = Arduino_skal_P.Kr * Arduino_skal_B.Step;



  /* Sum: '<Root>/Sum5' */

  Arduino_skal_B.Sum5 = Arduino_skal_B.Kr - Arduino_skal_B.Gain;



  /* Saturate: '<Root>/Saturation' */

  u0 = Arduino_skal_B.Sum5;

  tmp = Arduino_skal_P.Saturation_LowerSat;

  tmp_0 = Arduino_skal_P.Saturation_UpperSat;

  if (u0 > tmp_0) {

    /* Saturate: '<Root>/Saturation' */

    Arduino_skal_B.Saturation = tmp_0;

  } else if (u0 < tmp) {

    /* Saturate: '<Root>/Saturation' */

    Arduino_skal_B.Saturation = tmp;

  } else {

    /* Saturate: '<Root>/Saturation' */

    Arduino_skal_B.Saturation = u0;

  }



  /* End of Saturate: '<Root>/Saturation' */



  /* Product: '<S22>/B[k]*u[k]' incorporates:

   *  Constant: '<S1>/B'

   */

  currentTime = Arduino_skal_B.Saturation;

  u0 = Arduino_skal_P.B_Value[0];



  /* Product: '<S22>/B[k]*u[k]' */

  Arduino_skal_B.Bkuk[0] = u0 * currentTime;



  /* Product: '<S22>/B[k]*u[k]' incorporates:

   *  Constant: '<S1>/B'

   */

  u0 = Arduino_skal_P.B_Value[1];



  /* Product: '<S22>/B[k]*u[k]' */

  Arduino_skal_B.Bkuk[1] = u0 * currentTime;



  /* Product: '<S22>/B[k]*u[k]' incorporates:

   *  Constant: '<S1>/B'

   */

  u0 = Arduino_skal_P.B_Value[2];



  /* Product: '<S22>/B[k]*u[k]' */

  Arduino_skal_B.Bkuk[2] = u0 * currentTime;



  /* Product: '<S22>/B[k]*u[k]' incorporates:

   *  Constant: '<S1>/B'

   */

  u0 = Arduino_skal_P.B_Value[3];



  /* Product: '<S22>/B[k]*u[k]' */

  Arduino_skal_B.Bkuk[3] = u0 * currentTime;



  /* Outputs for Enabled SubSystem: '<S22>/MeasurementUpdate' incorporates:

   *  EnablePort: '<S53>/Enable'

   */

  if (rtmIsMajorTimeStep((&Arduino_skal_M)) && rtmIsMajorTimeStep

      ((&Arduino_skal_M))) {

    /* Constant: '<S1>/Enable' */

    if (Arduino_skal_P.Enable_Value) {

      Arduino_skal_DW.MeasurementUpdate_MODE = true;

    } else if (Arduino_skal_DW.MeasurementUpdate_MODE) {

      /* Disable for Product: '<S53>/Product3' incorporates:

       *  Outport: '<S53>/L*(y[k]-yhat[k|k-1])'

       */

      Arduino_skal_B.Product3[0] = Arduino_skal_P.Lykyhatkk1_Y0;

      Arduino_skal_B.Product3[1] = Arduino_skal_P.Lykyhatkk1_Y0;

      Arduino_skal_B.Product3[2] = Arduino_skal_P.Lykyhatkk1_Y0;

      Arduino_skal_B.Product3[3] = Arduino_skal_P.Lykyhatkk1_Y0;

      Arduino_skal_DW.MeasurementUpdate_MODE = false;

    }



    /* End of Constant: '<S1>/Enable' */

  }



  if (Arduino_skal_DW.MeasurementUpdate_MODE) {

    /* Product: '<S53>/C[k]*xhat[k|k-1]' incorporates:

     *  Constant: '<S1>/C'

     *  Product: '<S53>/Product3'

     */

    tmp_3 = &Arduino_skal_P.C_Value[0];

    tmp = Arduino_skal_B.MemoryX[0];

    tmp_0 = Arduino_skal_B.MemoryX[1];

    tmp_1 = Arduino_skal_B.MemoryX[2];

    tmp_2 = Arduino_skal_B.MemoryX[3];



    /* Product: '<S53>/D[k]*u[k]' */

    currentTime = Arduino_skal_B.Saturation;

    for (i = 0; i < 2; i++) {

      /* Product: '<S53>/C[k]*xhat[k|k-1]' */

      u0 = tmp_3[i] * tmp;

      u0 += tmp_3[i + 2] * tmp_0;

      u0 += tmp_3[i + 4] * tmp_1;

      u0 += tmp_3[i + 6] * tmp_2;



      /* Product: '<S53>/C[k]*xhat[k|k-1]' */

      Arduino_skal_B.Ckxhatkk1[i] = u0;



      /* Product: '<S53>/D[k]*u[k]' incorporates:

       *  Constant: '<S1>/D'

       */

      u0 = Arduino_skal_P.D_Value[i];



      /* Product: '<S53>/D[k]*u[k]' */

      Arduino_skal_B.Dkuk[i] = u0 * currentTime;



      /* Sum: '<S53>/Add1' incorporates:

       *  Product: '<S53>/D[k]*u[k]'

       */

      Arduino_skal_B.yhatkk1[i] = Arduino_skal_B.Ckxhatkk1[i] +

        Arduino_skal_B.Dkuk[i];



      /* Sum: '<S53>/Sum' incorporates:

       *  Constant: '<Root>/Constant'

       *  Sum: '<S53>/Add1'

       */

      Arduino_skal_B.Sum[i] = Arduino_skal_P.Constant_Value[i] -

        Arduino_skal_B.yhatkk1[i];

    }



    /* Product: '<S53>/Product3' incorporates:

     *  Constant: '<S2>/KalmanGainL'

     *  Product: '<S53>/C[k]*xhat[k|k-1]'

     *  Sum: '<S53>/Sum'

     */

    tmp_3 = &Arduino_skal_P.KalmanGainL_Value[0];

    tmp = Arduino_skal_B.Sum[0];

    tmp_0 = Arduino_skal_B.Sum[1];

    for (i = 0; i < 4; i++) {

      /* Product: '<S53>/Product3' */

      Arduino_skal_B.Product3[i] = 0.0;

      Arduino_skal_B.Product3[i] += tmp_3[i] * tmp;

      Arduino_skal_B.Product3[i] += tmp_3[i + 4] * tmp_0;

    }

  }



  /* End of Outputs for SubSystem: '<S22>/MeasurementUpdate' */



  /* Sum: '<S22>/Add' incorporates:

   *  Product: '<S22>/B[k]*u[k]'

   *  Product: '<S53>/Product3'

   */

  Arduino_skal_B.Add[0] = (Arduino_skal_B.Bkuk[0] + Arduino_skal_B.Akxhatkk1[0])

    + Arduino_skal_B.Product3[0];

  Arduino_skal_B.Add[1] = (Arduino_skal_B.Bkuk[1] + Arduino_skal_B.Akxhatkk1[1])

    + Arduino_skal_B.Product3[1];

  Arduino_skal_B.Add[2] = (Arduino_skal_B.Bkuk[2] + Arduino_skal_B.Akxhatkk1[2])

    + Arduino_skal_B.Product3[2];

  Arduino_skal_B.Add[3] = (Arduino_skal_B.Bkuk[3] + Arduino_skal_B.Akxhatkk1[3])

    + Arduino_skal_B.Product3[3];

  if (rtmIsMajorTimeStep((&Arduino_skal_M))) {

    /* Matfile logging */

    rt_UpdateTXYLogVars((&Arduino_skal_M)->rtwLogInfo, ((&Arduino_skal_M)

      ->Timing.t));

  }                                    /* end MajorTimeStep */



  if (rtmIsMajorTimeStep((&Arduino_skal_M))) {

    /* Update for Integrator: '<S1>/MemoryX' */

    Arduino_skal_DW.MemoryX_IWORK = 0;

  }                                    /* end MajorTimeStep */



  if (rtmIsMajorTimeStep((&Arduino_skal_M))) {

    /* signal main to stop simulation */

    {                                  /* Sample time: [0.0s, 0.0s] */

      if ((rtmGetTFinal((&Arduino_skal_M))!=-1) &&

          !((rtmGetTFinal((&Arduino_skal_M))-((((&Arduino_skal_M)

               ->Timing.clockTick1+(&Arduino_skal_M)->Timing.clockTickH1*

               4294967296.0)) * 0.2)) > ((((&Arduino_skal_M)->Timing.clockTick1+

              (&Arduino_skal_M)->Timing.clockTickH1* 4294967296.0)) * 0.2) *

            (DBL_EPSILON))) {

        rtmSetErrorStatus((&Arduino_skal_M), "Simulation finished");

      }

    }



    rt_ertODEUpdateContinuousStates(&(&Arduino_skal_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.

     * Timer of this task consists of two 32 bit unsigned integers.

     * The two integers represent the low bits Timing.clockTick0 and the high bits

     * Timing.clockTickH0. When the low bit overflows to 0, the high bits increment.

     */

    if (!(++(&Arduino_skal_M)->Timing.clockTick0)) {

      ++(&Arduino_skal_M)->Timing.clockTickH0;

    }



    (&Arduino_skal_M)->Timing.t[0] = rtsiGetSolverStopTime(&(&Arduino_skal_M)

      ->solverInfo);



    {

      /* Update absolute timer for sample time: [0.2s, 0.0s] */

      /* The "clockTick1" counts the number of times the code of this task has

       * been executed. The resolution of this integer timer is 0.2, which is the step size

       * of the task. Size of "clockTick1" ensures timer will not overflow during the

       * application lifespan selected.

       * Timer of this task consists of two 32 bit unsigned integers.

       * The two integers represent the low bits Timing.clockTick1 and the high bits

       * Timing.clockTickH1. When the low bit overflows to 0, the high bits increment.

       */

      (&Arduino_skal_M)->Timing.clockTick1++;

      if (!(&Arduino_skal_M)->Timing.clockTick1) {

        (&Arduino_skal_M)->Timing.clockTickH1++;

      }

    }

  }                                    /* end MajorTimeStep */

}



/* Derivatives for root system: '<Root>' */

void Arduino_skalModelClass::Arduino_skal_derivatives()

{

  XDot_Arduino_skal_T *_rtXdot;

  _rtXdot = ((XDot_Arduino_skal_T *) (&Arduino_skal_M)->derivs);



  /* Derivatives for Integrator: '<S1>/MemoryX' */

  _rtXdot->MemoryX_CSTATE[0] = Arduino_skal_B.Add[0];

  _rtXdot->MemoryX_CSTATE[1] = Arduino_skal_B.Add[1];

  _rtXdot->MemoryX_CSTATE[2] = Arduino_skal_B.Add[2];

  _rtXdot->MemoryX_CSTATE[3] = Arduino_skal_B.Add[3];

}



/* Model initialize function */

void Arduino_skalModelClass::initialize()

{

  /* Registration code */



  /* initialize non-finites */

  rt_InitInfAndNaN(sizeof(real_T));



  {

    /* Setup solver object */

    rtsiSetSimTimeStepPtr(&(&Arduino_skal_M)->solverInfo, &(&Arduino_skal_M)

                          ->Timing.simTimeStep);

    rtsiSetTPtr(&(&Arduino_skal_M)->solverInfo, &rtmGetTPtr((&Arduino_skal_M)));

    rtsiSetStepSizePtr(&(&Arduino_skal_M)->solverInfo, &(&Arduino_skal_M)

                       ->Timing.stepSize0);

    rtsiSetdXPtr(&(&Arduino_skal_M)->solverInfo, &(&Arduino_skal_M)->derivs);

    rtsiSetContStatesPtr(&(&Arduino_skal_M)->solverInfo, (real_T **)

                         &(&Arduino_skal_M)->contStates);

    rtsiSetNumContStatesPtr(&(&Arduino_skal_M)->solverInfo, &(&Arduino_skal_M)

      ->Sizes.numContStates);

    rtsiSetNumPeriodicContStatesPtr(&(&Arduino_skal_M)->solverInfo,

      &(&Arduino_skal_M)->Sizes.numPeriodicContStates);

    rtsiSetPeriodicContStateIndicesPtr(&(&Arduino_skal_M)->solverInfo,

      &(&Arduino_skal_M)->periodicContStateIndices);

    rtsiSetPeriodicContStateRangesPtr(&(&Arduino_skal_M)->solverInfo,

      &(&Arduino_skal_M)->periodicContStateRanges);

    rtsiSetErrorStatusPtr(&(&Arduino_skal_M)->solverInfo, (&rtmGetErrorStatus

      ((&Arduino_skal_M))));

    rtsiSetRTModelPtr(&(&Arduino_skal_M)->solverInfo, (&Arduino_skal_M));

  }



  rtsiSetSimTimeStep(&(&Arduino_skal_M)->solverInfo, MAJOR_TIME_STEP);

  (&Arduino_skal_M)->intgData.y = (&Arduino_skal_M)->odeY;

  (&Arduino_skal_M)->intgData.f[0] = (&Arduino_skal_M)->odeF[0];

  (&Arduino_skal_M)->intgData.f[1] = (&Arduino_skal_M)->odeF[1];

  (&Arduino_skal_M)->intgData.f[2] = (&Arduino_skal_M)->odeF[2];

  (&Arduino_skal_M)->contStates = ((X_Arduino_skal_T *) &Arduino_skal_X);

  rtsiSetSolverData(&(&Arduino_skal_M)->solverInfo, static_cast<void *>

                    (&(&Arduino_skal_M)->intgData));

  rtsiSetSolverName(&(&Arduino_skal_M)->solverInfo,"ode3");

  rtmSetTPtr((&Arduino_skal_M), &(&Arduino_skal_M)->Timing.tArray[0]);

  rtmSetTFinal((&Arduino_skal_M), 10.0);

  (&Arduino_skal_M)->Timing.stepSize0 = 0.2;

  rtmSetFirstInitCond((&Arduino_skal_M), 1);



  /* Setup for data logging */

  {

    static RTWLogInfo rt_DataLoggingInfo;

    rt_DataLoggingInfo.loggingInterval = (NULL);

    (&Arduino_skal_M)->rtwLogInfo = &rt_DataLoggingInfo;

  }



  /* Setup for data logging */

  {

    rtliSetLogXSignalInfo((&Arduino_skal_M)->rtwLogInfo, (NULL));

    rtliSetLogXSignalPtrs((&Arduino_skal_M)->rtwLogInfo, (NULL));

    rtliSetLogT((&Arduino_skal_M)->rtwLogInfo, "tout");

    rtliSetLogX((&Arduino_skal_M)->rtwLogInfo, "");

    rtliSetLogXFinal((&Arduino_skal_M)->rtwLogInfo, "");

    rtliSetLogVarNameModifier((&Arduino_skal_M)->rtwLogInfo, "rt_");

    rtliSetLogFormat((&Arduino_skal_M)->rtwLogInfo, 4);

    rtliSetLogMaxRows((&Arduino_skal_M)->rtwLogInfo, 0);

    rtliSetLogDecimation((&Arduino_skal_M)->rtwLogInfo, 1);

    rtliSetLogY((&Arduino_skal_M)->rtwLogInfo, "");

    rtliSetLogYSignalInfo((&Arduino_skal_M)->rtwLogInfo, (NULL));

    rtliSetLogYSignalPtrs((&Arduino_skal_M)->rtwLogInfo, (NULL));

  }



  /* Matfile logging */

  rt_StartDataLoggingWithStartTime((&Arduino_skal_M)->rtwLogInfo, 0.0,

    rtmGetTFinal((&Arduino_skal_M)), (&Arduino_skal_M)->Timing.stepSize0,

    (&rtmGetErrorStatus((&Arduino_skal_M))));



  /* Start for Constant: '<S1>/X0' */

  Arduino_skal_B.X0[0] = Arduino_skal_P.X0_Value[0];

  Arduino_skal_B.X0[1] = Arduino_skal_P.X0_Value[1];

  Arduino_skal_B.X0[2] = Arduino_skal_P.X0_Value[2];

  Arduino_skal_B.X0[3] = Arduino_skal_P.X0_Value[3];



  /* InitializeConditions for Integrator: '<S1>/MemoryX' */

  if (rtmIsFirstInitCond((&Arduino_skal_M))) {

    Arduino_skal_X.MemoryX_CSTATE[0] = 0.0;

    Arduino_skal_X.MemoryX_CSTATE[1] = 0.0;

    Arduino_skal_X.MemoryX_CSTATE[2] = 0.0;

    Arduino_skal_X.MemoryX_CSTATE[3] = 0.0;

  }



  Arduino_skal_DW.MemoryX_IWORK = 1;



  /* End of InitializeConditions for Integrator: '<S1>/MemoryX' */



  /* SystemInitialize for Enabled SubSystem: '<S22>/MeasurementUpdate' */

  /* SystemInitialize for Product: '<S53>/Product3' incorporates:

   *  Outport: '<S53>/L*(y[k]-yhat[k|k-1])'

   */

  Arduino_skal_B.Product3[0] = Arduino_skal_P.Lykyhatkk1_Y0;

  Arduino_skal_B.Product3[1] = Arduino_skal_P.Lykyhatkk1_Y0;

  Arduino_skal_B.Product3[2] = Arduino_skal_P.Lykyhatkk1_Y0;

  Arduino_skal_B.Product3[3] = Arduino_skal_P.Lykyhatkk1_Y0;



  /* End of SystemInitialize for SubSystem: '<S22>/MeasurementUpdate' */



  /* set "at time zero" to false */

  if (rtmIsFirstInitCond((&Arduino_skal_M))) {

    rtmSetFirstInitCond((&Arduino_skal_M), 0);

  }

}



/* Model terminate function */

void Arduino_skalModelClass::terminate()

{

  /* (no terminate code required) */

}



/* Constructor */

Arduino_skalModelClass::Arduino_skalModelClass() :

  Arduino_skal_B(),

  Arduino_skal_DW(),

  Arduino_skal_X(),

  Arduino_skal_M()

{

  /* Currently there is no constructor body generated.*/

}



/* Destructor */

Arduino_skalModelClass::~Arduino_skalModelClass()

{

  /* Currently there is no destructor body generated.*/

}



/* Real-Time Model get method */

RT_MODEL_Arduino_skal_T * Arduino_skalModelClass::getRTM()

{

  return (&Arduino_skal_M);

}