main_code

/*
 * File: stills_R_Wsdfdsgfsdhfghggfh.c
 *
.
 *
 
 * C source code generated on           : Wed Aug 17 00:57:55 2016
 */

#include "stills_R_Wsdfdsgfsdhfghggfh.h"
#include "stills_R_Wsdfdsgfsdhfghggfh_private.h"

RTDX_CreateInputChannel(inputimage);   /* Channel inputimage for block <Root>/From RTDX */
RTDX_CreateOutputChannel(outputimage); /* Channel outputimage for block <Root>/To RTDX */

/* Block signals (auto storage) */
#pragma DATA_ALIGN(stills_R_Wsdfdsgfsdhfghggfh_B, 8)

BlockIO_stills_R_Wsdfdsgfsdhfgh stills_R_Wsdfdsgfsdhfghggfh_B;

/* Real-time model */
RT_MODEL_stills_R_Wsdfdsgfsdhfg stills_R_Wsdfdsgfsdhfghggfh_M_;
RT_MODEL_stills_R_Wsdfdsgfsdhfg *stills_R_Wsdfdsgfsdhfghggfh_M =
  &stills_R_Wsdfdsgfsdhfghggfh_M_;

/* Model step function */
void stills_R_Wsdfdsgfsdhfghggfh_step(void)
{
  /* local block i/o variables */
  real_T rtb_Add;
  real_T rtb_Add_k[3];
  real_T rtb_Sum1;
  real_T rtb_MathFunction3;
  real_T rtb_Sum2;

  {
    real_T uDiv;
    real_T uDivRound;

    /* S-Function Block: <Root>/From RTDX (rtdx_src) */
    RTDX_read( &inputimage, (void*) stills_R_Wsdfdsgfsdhfghggfh_B.FromRTDX, 3*
              sizeof(real_T));

    /* Math: '<S2>/Math Function' incorporates:
     *  Constant: '<Root>/Constant5'
     *  Constant: '<S2>/Constant'
     */
    if (stills_R_Wsdfdsgfsdhfghggfh_P.Constant_Value == 0.0) {
      rtb_Sum1 = stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value;
    } else if (stills_R_Wsdfdsgfsdhfghggfh_P.Constant_Value <= floor
               (stills_R_Wsdfdsgfsdhfghggfh_P.Constant_Value)) {
      rtb_Sum1 = stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value - floor
        (stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value /
         stills_R_Wsdfdsgfsdhfghggfh_P.Constant_Value) *
        stills_R_Wsdfdsgfsdhfghggfh_P.Constant_Value;
    } else {
      uDiv = stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value /
        stills_R_Wsdfdsgfsdhfghggfh_P.Constant_Value;
      uDivRound = floor(fabs(uDiv) + 0.5);
      if (uDiv < 0.0) {
        uDivRound = -uDivRound;
      }

      if (fabs(uDiv - uDivRound) <= DBL_EPSILON * fabs(uDiv)) {
        rtb_Sum1 = 0.0;
      } else {
        rtb_Sum1 = (uDiv - floor(uDiv)) *
          stills_R_Wsdfdsgfsdhfghggfh_P.Constant_Value;
      }
    }

    /* S-Function (sdspsubmtrx): '<S2>/Submatrix' incorporates:
     *  Constant: '<Root>/Constant1'
     */
    stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix[0] =
      stills_R_Wsdfdsgfsdhfghggfh_P.Constant1_Value[1];
    stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix[1] =
      stills_R_Wsdfdsgfsdhfghggfh_P.Constant1_Value[4];
    stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix[2] =
      stills_R_Wsdfdsgfsdhfghggfh_P.Constant1_Value[7];

    /* MultiPortSwitch: '<S2>/Index Vector' incorporates:
     *  Bias: '<S2>/Bias'
     */
    switch ((int32_T)(rtb_Sum1 + stills_R_Wsdfdsgfsdhfghggfh_P.Bias_Bias)) {
     case 1:
      rtb_Sum1 = stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix[0];
      break;

     case 2:
      rtb_Sum1 = stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix[1];
      break;

     default:
      rtb_Sum1 = stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix[2];
      break;
    }

    /* Rounding: '<S2>/Rounding Function1' incorporates:
     *  Bias: '<S2>/Bias1'
     *  Constant: '<Root>/Constant5'
     *  Fcn: '<S2>/Fcn'
     *  Rounding: '<S2>/Rounding Function'
     */
    rtb_Sum2 = ceil(floor(log(stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value)) +
                    stills_R_Wsdfdsgfsdhfghggfh_P.Bias1_Bias);

    /* Math: '<S2>/Math Function1' incorporates:
     *  Constant: '<S2>/Constant1'
     */
    if ((stills_R_Wsdfdsgfsdhfghggfh_P.Constant1_Value_h < 0.0) && (rtb_Sum2 >
         floor(rtb_Sum2))) {
      rtb_Sum2 = -pow(-stills_R_Wsdfdsgfsdhfghggfh_P.Constant1_Value_h, rtb_Sum2);
    } else {
      rtb_Sum2 = pow(stills_R_Wsdfdsgfsdhfghggfh_P.Constant1_Value_h, rtb_Sum2);
    }

    /* Math: '<S2>/Math Function2' incorporates:
     *  Constant: '<Root>/Constant5'
     */
    if (rtb_Sum2 == 0.0) {
      rtb_MathFunction3 = stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value;
    } else if (rtb_Sum2 <= floor(rtb_Sum2)) {
      rtb_MathFunction3 = stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value - floor
        (stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value / rtb_Sum2) * rtb_Sum2;
    } else {
      uDiv = stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value / rtb_Sum2;
      uDivRound = floor(fabs(uDiv) + 0.5);
      if (uDiv < 0.0) {
        uDivRound = -uDivRound;
      }

      if (fabs(uDiv - uDivRound) <= DBL_EPSILON * fabs(uDiv)) {
        rtb_MathFunction3 = 0.0;
      } else {
        rtb_MathFunction3 = (uDiv - floor(uDiv)) * rtb_Sum2;
      }
    }

    /* Sum: '<S2>/Add' */
    rtb_Add = rtb_Sum2 + rtb_MathFunction3;

    /* Sum: '<S2>/Sum' incorporates:
     *  Constant: '<Root>/Constant2'
     *  Constant: '<Root>/Constant3'
     *  Constant: '<Root>/Constant4'
     *  Constant: '<S2>/Constant2'
     *  Product: '<S2>/Product1'
     */
    rtb_MathFunction3 = stills_R_Wsdfdsgfsdhfghggfh_P.Constant2_Value *
      stills_R_Wsdfdsgfsdhfghggfh_P.Constant3_Value *
      stills_R_Wsdfdsgfsdhfghggfh_P.Constant2_Value_f +
      stills_R_Wsdfdsgfsdhfghggfh_P.Constant4_Value;

    /* Math: '<S2>/Math Function3' incorporates:
     *  Constant: '<S2>/Constant3'
     */
    if (!(stills_R_Wsdfdsgfsdhfghggfh_P.Constant3_Value_g == 0.0)) {
      if (stills_R_Wsdfdsgfsdhfghggfh_P.Constant3_Value_g <= floor
          (stills_R_Wsdfdsgfsdhfghggfh_P.Constant3_Value_g)) {
        rtb_MathFunction3 -= floor(rtb_MathFunction3 /
          stills_R_Wsdfdsgfsdhfghggfh_P.Constant3_Value_g) *
          stills_R_Wsdfdsgfsdhfghggfh_P.Constant3_Value_g;
      } else {
        uDiv = rtb_MathFunction3 /
          stills_R_Wsdfdsgfsdhfghggfh_P.Constant3_Value_g;
        uDivRound = floor(fabs(uDiv) + 0.5);
        if (uDiv < 0.0) {
          uDivRound = -uDivRound;
        }

        if (fabs(uDiv - uDivRound) <= DBL_EPSILON * fabs(uDiv)) {
          rtb_MathFunction3 = 0.0;
        } else {
          rtb_MathFunction3 = (uDiv - floor(uDiv)) *
            stills_R_Wsdfdsgfsdhfghggfh_P.Constant3_Value_g;
        }
      }
    }

    /* Sum: '<S2>/Sum1' incorporates:
     *  Product: '<S2>/Product'
     */
    rtb_Sum1 += rtb_Add * rtb_MathFunction3;

    /* Math: '<S2>/Math Function4' incorporates:
     *  Constant: '<S2>/Constant4'
     */
    if (stills_R_Wsdfdsgfsdhfghggfh_P.Constant4_Value_n == 0.0) {
      rtb_Sum2 = rtb_Sum1;
    } else if (stills_R_Wsdfdsgfsdhfghggfh_P.Constant4_Value_n <= floor
               (stills_R_Wsdfdsgfsdhfghggfh_P.Constant4_Value_n)) {
      rtb_Sum2 = rtb_Sum1 - floor(rtb_Sum1 /
        stills_R_Wsdfdsgfsdhfghggfh_P.Constant4_Value_n) *
        stills_R_Wsdfdsgfsdhfghggfh_P.Constant4_Value_n;
    } else {
      uDiv = rtb_Sum1 / stills_R_Wsdfdsgfsdhfghggfh_P.Constant4_Value_n;
      uDivRound = floor(fabs(uDiv) + 0.5);
      if (uDiv < 0.0) {
        uDivRound = -uDivRound;
      }

      if (fabs(uDiv - uDivRound) <= DBL_EPSILON * fabs(uDiv)) {
        rtb_Sum2 = 0.0;
      } else {
        rtb_Sum2 = (uDiv - floor(uDiv)) *
          stills_R_Wsdfdsgfsdhfghggfh_P.Constant4_Value_n;
      }
    }

    /* S-Function (sdspsubmtrx): '<S2>/Submatrix1' incorporates:
     *  Constant: '<Root>/Constant1'
     */
    stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix1[0] =
      stills_R_Wsdfdsgfsdhfghggfh_P.Constant1_Value[1];
    stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix1[1] =
      stills_R_Wsdfdsgfsdhfghggfh_P.Constant1_Value[4];
    stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix1[2] =
      stills_R_Wsdfdsgfsdhfghggfh_P.Constant1_Value[7];

    /* MultiPortSwitch: '<S2>/Index Vector1' incorporates:
     *  Bias: '<S2>/Bias2'
     */
    switch ((int32_T)(rtb_Sum2 + stills_R_Wsdfdsgfsdhfghggfh_P.Bias2_Bias)) {
     case 1:
      rtb_Sum2 = stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix1[0];
      break;

     case 2:
      rtb_Sum2 = stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix1[1];
      break;

     default:
      rtb_Sum2 = stills_R_Wsdfdsgfsdhfghggfh_B.Submatrix1[2];
      break;
    }

    /* Rounding: '<S2>/Rounding Function3' incorporates:
     *  Bias: '<S2>/Bias3'
     *  Fcn: '<S2>/Fcn1'
     *  Rounding: '<S2>/Rounding Function2'
     */
    rtb_Add = ceil(floor(log(rtb_Sum1)) +
                   stills_R_Wsdfdsgfsdhfghggfh_P.Bias3_Bias);

    /* Math: '<S2>/Math Function5' incorporates:
     *  Constant: '<S2>/Constant5'
     */
    if ((stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value_m < 0.0) && (rtb_Add >
         floor(rtb_Add))) {
      rtb_Add = -pow(-stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value_m, rtb_Add);
    } else {
      rtb_Add = pow(stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value_m, rtb_Add);
    }

    /* Math: '<S2>/Math Function6' */
    if (rtb_Add == 0.0) {
      uDiv = rtb_Sum1;
    } else if (rtb_Add <= floor(rtb_Add)) {
      uDiv = rtb_Sum1 - floor(rtb_Sum1 / rtb_Add) * rtb_Add;
    } else {
      uDiv = rtb_Sum1 / rtb_Add;
      uDivRound = floor(fabs(uDiv) + 0.5);
      if (uDiv < 0.0) {
        uDivRound = -uDivRound;
      }

      if (fabs(uDiv - uDivRound) <= DBL_EPSILON * fabs(uDiv)) {
        uDiv = 0.0;
      } else {
        uDiv = (uDiv - floor(uDiv)) * rtb_Add;
      }
    }

    /* Sum: '<S2>/Sum2' incorporates:
     *  Product: '<S2>/Product3'
     *  Sum: '<S2>/Add1'
     */
    rtb_Sum2 += (rtb_Add + uDiv) * rtb_MathFunction3;

    /* Sum: '<Root>/Add' incorporates:
     *  Constant: '<Root>/Constant5'
     */
    rtb_Add_k[0] = stills_R_Wsdfdsgfsdhfghggfh_B.FromRTDX[0] +
      stills_R_Wsdfdsgfsdhfghggfh_P.Constant5_Value;
    rtb_Add_k[1] = stills_R_Wsdfdsgfsdhfghggfh_B.FromRTDX[1] + rtb_Sum1;
    rtb_Add_k[2] = stills_R_Wsdfdsgfsdhfghggfh_B.FromRTDX[2] + rtb_Sum2;

    /* S-Function Block: <Root>/To RTDX (rtdx_snk) */
    if (RTDX_isOutputEnabled( &outputimage )) {
      while (RTDX_writing != NULL) {
      }                                /* waiting for rtdx write to complete */

      RTDX_write( &outputimage, (void*) rtb_Add_k, 3*sizeof(real_T));
    }
  }
}

/* Model initialize function */
void stills_R_Wsdfdsgfsdhfghggfh_initialize(boolean_T firstTime)
{
  (void)firstTime;

  /* Registration code */

  /* initialize error status */
  rtmSetErrorStatus(stills_R_Wsdfdsgfsdhfghggfh_M, (const char_T *)0);

  /* block I/O */
  {
    int_T i;
    void *pVoidBlockIORegion;
    pVoidBlockIORegion = (void *)(&stills_R_Wsdfdsgfsdhfghggfh_B.FromRTDX[0]);
    for (i = 0; i < 9; i++) {
      ((real_T*)pVoidBlockIORegion)[i] = 0.0;
    }
  }

  /* From RTDX (rtdx_src) */
  {
    RTDX_enableInput(&inputimage);
  }

  RTDX_enableOutput(&outputimage);     /* To RTDX (rtdx_snk) */
}

/* Model terminate function */
void stills_R_Wsdfdsgfsdhfghggfh_terminate(void)
{
  RTDX_disableInput(&inputimage);      /*: <Root>/From RTDX (rtdx_src) */
  RTDX_disableOutput(&outputimage);    /*To RTDX (rtdx_snk) */
}

/* File trailer for Real-Time Workshop generated code.
 *
 * [EOF]
 */

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
 * File: stills_R_Wsdfdsgfsdhfghggfh_data.c
 *
* C source code generated on           : Wed Aug 17 00:57:55 2016
 */

#include "stills_R_Wsdfdsgfsdhfghggfh.h"
#include "stills_R_Wsdfdsgfsdhfghggfh_private.h"

/* Block parameters (auto storage) */

#pragma DATA_ALIGN(stills_R_Wsdfdsgfsdhfghggfh_P, 8)

Parameters_stills_R_Wsdfdsgfsdh stills_R_Wsdfdsgfsdhfghggfh_P = {
  0.0,                                 /* FromRTDX_IC : '<Root>/From RTDX'
                                        */
  2.0,                                 /* Constant5_Value : '<Root>/Constant5'
                                        */
  3.0,                                 /* Constant_Value : '<S2>/Constant'
                                        */
  1.0,                                 /* Bias_Bias : '<S2>/Bias'
                                        */

  /*  Constant1_Value : '<Root>/Constant1'
   */
  { 1.0, 1.0, 4.0, 2.0, 2.0, 5.0, 3.0, 3.0, 6.0 },
  2.0,                                 /* Constant1_Value_h : '<S2>/Constant1'
                                        */
  1.0,                                 /* Bias1_Bias : '<S2>/Bias1'
                                        */
  2.0,                                 /* Constant2_Value : '<Root>/Constant2'
                                        */
  2.0,                                 /* Constant3_Value : '<Root>/Constant3'
                                        */
  10.0,                                /* Constant2_Value_f : '<S2>/Constant2'
                                        */
  2.0,                                 /* Constant4_Value : '<Root>/Constant4'
                                        */
  113.0,                               /* Constant3_Value_g : '<S2>/Constant3'
                                        */
  3.0,                                 /* Constant4_Value_n : '<S2>/Constant4'
                                        */
  1.0,                                 /* Bias2_Bias : '<S2>/Bias2'
                                        */
  2.0,                                 /* Constant5_Value_m : '<S2>/Constant5'
                                        */
  1.0                                  /* Bias3_Bias : '<S2>/Bias3'
                                        */
};

/* File trailer for Real-Time Workshop generated code.
 *
 * [EOF]
 */
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
 * File: stills_R_Wsdfdsgfsdhfghggfh_main.c
 *
* C source code generated on           : Wed Aug 17 00:57:55 2016
 */

#include "stills_R_Wsdfdsgfsdhfghggfh_main.h"
#include "stills_R_Wsdfdsgfsdhfghggfh.h"
#include "stills_R_Wsdfdsgfsdhfghggfh_private.h"
#include "stills_R_Wsdfdsgfsdhfghggfhcfg.h"
#include "rtwtypes.h"
#include "MW_c6xxx_csl.h"
#include "c6000_main.h"
#include <stdlib.h>
#include <stdio.h>
#define DSK_CPLD_BASE                  0x60000000
#define DSK_USER_REG                   0

/* Function: exitprocessing ----------------------------------
 *
 * Abstract:
 *      Perform various tasks at program exit.
 */
void exitprocessing()
{
  disable_interrupts();
  SYS_exit(-1);
}

void tBaseRateTSK_fcn(void)
{
  volatile boolean_T noErr;
  TSK_prolog( TSK_self() );
  noErr =
    rtmGetErrorStatus(stills_R_Wsdfdsgfsdhfghggfh_M) == NULL;
  while (noErr ) {
    /* Wait for the next timer interrupt */
    SEM_pend(&rtClockSEM, SYS_FOREVER);
    stills_R_Wsdfdsgfsdhfghggfh_step();
    noErr =
      rtmGetErrorStatus(stills_R_Wsdfdsgfsdhfghggfh_M) == NULL;
  }                                    /* while */

  SEM_post(&stopSEM);
}

void main(void)
{
  setupCache();
  LOG_printf(&LOG_MW1, "**starting the model**");

  /* Drop out of main() and enter DSP/BIOS Kernel */
}

//
// TSK prolog/epilog functions.
//
void TSK_prolog(TSK_Handle hTask)
{

#ifdef ENET_SOCKET_CALLS

  fdOpenSession( hTask );

#endif

}

void TSK_epilog(TSK_Handle hTask)
{

#ifdef ENET_SOCKET_CALLS

  fdCloseSession( hTask );

#endif

}

//
// This task is run at the highest priority. It is used to
// initialize the model and also to monitor stopping conditions.
// OS executes this task immidiately after falling out of main().
//
void initTerminateTSK_fcn(void)
{
  stills_R_Wsdfdsgfsdhfghggfh_initialize(1);
  enable_interrupts();
  configureTimers();

  /* Wait for a stopping condition. */
  SEM_pend(&stopSEM, SYS_FOREVER);

  /* We have acquired the STOP semaphore. Perform model termination. */
  /* Suspend syncronous tasks */
  {
    TSK_epilog( &tBaseRateTSK );
    TSK_setpri( &tBaseRateTSK, -1 );
  }

  LOG_printf(&LOG_MW1, "**stopping the model**");

  /* Disable rt_OneStep() here */

  /* Terminate model */
  stills_R_Wsdfdsgfsdhfghggfh_terminate();
  targetTerminate();
}

/* File trailer for Real-Time Workshop generated code.
 *
 * [EOF]
 */