/*

 * File: PMSM_Controller.c

 *

 * Code generated for Simulink model 'PMSM_Controller'.

 *

 * Model version                  : 1.885

 * Simulink Coder version         : 9.4 (R2020b) 29-Jul-2020

 * C/C++ source code generated on : Sat Jan  8 15:44:11 2022

 *

 * Target selection: ert.tlc

 * Embedded hardware selection: ARM Compatible->ARM Cortex-M

 * Code generation objectives:

 *    1. Execution efficiency

 *    2. RAM efficiency

 * Validation result: Not run

 */



#include "PMSM_Controller.h"

#include "PMSM_Controller_private.h"



static void rate_scheduler(RT_MODEL *const rtM);

uint16_T plook_u16u16_evencka(uint16_T u, uint16_T bp0, uint16_T bpSpace,

  uint32_T maxIndex)

{

  uint16_T bpIndex;



  /* Prelookup - Index only

     Index Search method: 'even'

     Extrapolation method: 'Clip'

     Use previous index: 'off'

     Use last breakpoint for index at or above upper limit: 'on'

     Remove protection against out-of-range input in generated code: 'off'

   */

  if (u <= bp0) {

    bpIndex = 0U;

  } else {

    bpIndex = (uint16_T)((uint32_T)(uint16_T)((uint32_T)u - bp0) / bpSpace);

    if (bpIndex < maxIndex) {

    } else {

      bpIndex = (uint16_T)maxIndex;

    }

  }



  return bpIndex;

}



int32_T div_nde_s32_floor(int32_T numerator, int32_T denominator)

{

  return (((numerator < 0) != (denominator < 0)) && (numerator % denominator !=

           0) ? -1 : 0) + numerator / denominator;

}



/*

 *   This function updates active task flag for each subrate.

 * The function is called at model base rate, hence the

 * generated code self-manages all its subrates.

 */

static void rate_scheduler(RT_MODEL *const rtM)

{

  /* Compute which subrates run during the next base time step.  Subrates

   * are an integer multiple of the base rate counter.  Therefore, the subtask

   * counter is reset when it reaches its limit (zero means run).

   */

  (rtM->Timing.TaskCounters.TID[1])++;

  if ((rtM->Timing.TaskCounters.TID[1]) > 9) {/* Sample time: [6.2E-5s, 0.0s] */

    rtM->Timing.TaskCounters.TID[1] = 0;

  }

}



real_T rt_modd_snf(real_T u0, real_T u1)

{

  real_T q;

  real_T y;

  boolean_T yEq;

  y = u0;

  if (u1 == 0.0) {

    if (u0 == 0.0) {

      y = u1;

    }

  } else if (rtIsNaN(u0) || rtIsNaN(u1) || rtIsInf(u0)) {

    y = (rtNaN);

  } else if (u0 == 0.0) {

    y = 0.0 / u1;

  } else if (rtIsInf(u1)) {

    if ((u1 < 0.0) != (u0 < 0.0)) {

      y = u1;

    }

  } else {

    y = fmod(u0, u1);

    yEq = (y == 0.0);

    if ((!yEq) && (u1 > floor(u1))) {

      q = fabs(u0 / u1);

      yEq = !(fabs(q - floor(q + 0.5)) > DBL_EPSILON * q);

    }



    if (yEq) {

      y = u1 * 0.0;

    } else {

      if ((u0 < 0.0) != (u1 < 0.0)) {

        y += u1;

      }

    }

  }



  return y;

}



real_T rt_roundd_snf(real_T u)

{

  real_T y;

  if (fabs(u) < 4.503599627370496E+15) {

    if (u >= 0.5) {

      y = floor(u + 0.5);

    } else if (u > -0.5) {

      y = u * 0.0;

    } else {

      y = ceil(u - 0.5);

    }

  } else {

    y = u;

  }



  return y;

}



/* Model step function */

void PMSM_Controller_step(RT_MODEL *const rtM, int16_T rtU_Vdc, uint16_T rtU_Ts,

  int16_T rtU_adc_a, int16_T rtU_adc_b, real_T rtU_rotor_angle, int16_T

  rtU_rotor_speed, int16_T rtU_input_target, uint16_T rtY_pwm_counts[8], uint8_T

  *rtY_sector)

{

  DW *rtDW = rtM->dwork;

  int32_T rtb_Sum1_tmp;

  int32_T rtb_Sum3_idx_0;

  int32_T rtb_Sum3_idx_1;

  int32_T tmp;

  int32_T tmp_0;

  int16_T rtb_Divide;

  int16_T rtb_Divide4;

  int16_T rtb_Divide7;

  int16_T rtb_Multiply_idx_0;

  int16_T rtb_Multiply_idx_1;

  int16_T rtb_SignPreIntegrator;

  int16_T rtb_SignPreSat;

  int16_T rtb_SignPreSat_k;

  int16_T rtb_Sum1;

  int16_T rtb_Sum2;

  int16_T rtb_Sum3_l;

  uint16_T rtb_DataTypeConversion3;

  uint16_T rtb_MultiportSwitch_idx_0;

  uint16_T rtb_MultiportSwitch_idx_1;

  uint16_T rtb_o_samp_p1;

  uint8_T rtb_DataTypeConversion_a;

  boolean_T rtb_NotEqual;



  /* Gain: '<S1>/Multiply' incorporates:

   *  Inport: '<Root>/adc_a'

   *  Inport: '<Root>/adc_b'

   */

  rtb_Multiply_idx_0 = (int16_T)((19761 * rtU_adc_a) >> 17);

  rtb_Multiply_idx_1 = (int16_T)((19761 * rtU_adc_b) >> 17);



  /* Outputs for Atomic SubSystem: '<S1>/controller' */

  /* PreLookup: '<S23>/a_elecAngle_XA' incorporates:

   *  Constant: '<S1>/Constant1'

   *  Gain: '<S1>/Gain'

   *  Inport: '<Root>/rotor_angle'

   *  Math: '<S1>/Math Function'

   */

  rtb_o_samp_p1 = plook_u16u16_evencka((uint16_T)(57.295779513082323 *

    rt_modd_snf(rtU_rotor_angle, 6.2831853071795862)), 0U, 1U, 360U);



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

   *  Product: '<S177>/Divide4'

   *  Sum: '<S15>/Add'

   */

  rtb_Divide4 = (int16_T)-(rtb_Multiply_idx_0 + rtb_Multiply_idx_1);



  /* Gain: '<S20>/Gain1' incorporates:

   *  Gain: '<S20>/Gain'

   *  Product: '<S177>/Divide'

   *  Product: '<S177>/Divide4'

   *  Sum: '<S20>/Add'

   *  Sum: '<S20>/Add1'

   */

  rtb_Divide = (int16_T)(((((rtb_Multiply_idx_0 << 1) - rtb_Multiply_idx_1) -

    rtb_Divide4) * 21845) >> 16);



  /* Gain: '<S20>/Gain2' incorporates:

   *  Product: '<S177>/Divide4'

   *  Sum: '<S20>/Add2'

   */

  rtb_Divide4 = (int16_T)(((rtb_Multiply_idx_1 - rtb_Divide4) * 18919) >> 15);



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

   *  Interpolation_n-D: '<S23>/r_cos_M1'

   *  Interpolation_n-D: '<S23>/r_sin_M1'

   *  Product: '<S177>/Divide'

   *  Product: '<S177>/Divide4'

   *  Product: '<S22>/Divide2'

   *  Product: '<S22>/Divide3'

   */

  rtb_Sum1_tmp = ((rtb_Divide * rtConstP.r_cos_M1_Table[rtb_o_samp_p1]) >> 14) +

    ((rtb_Divide4 * rtConstP.r_sin_M1_Table[rtb_o_samp_p1]) >> 14);

  if (rtb_Sum1_tmp > 32767) {

    rtb_Sum1_tmp = 32767;

  } else {

    if (rtb_Sum1_tmp < -32768) {

      rtb_Sum1_tmp = -32768;

    }

  }



  /* Sum: '<S21>/Sum2' incorporates:

   *  Sum: '<S22>/Sum1'

   *  UnitDelay: '<S21>/UnitDelay1'

   */

  rtb_Sum1_tmp -= rtDW->UnitDelay1_DSTATE[0] >> 16;

  if (rtb_Sum1_tmp > 32767) {

    rtb_Sum1_tmp = 32767;

  } else {

    if (rtb_Sum1_tmp < -32768) {

      rtb_Sum1_tmp = -32768;

    }

  }



  /* Sum: '<S21>/Sum3' incorporates:

   *  Constant: '<S15>/Constant'

   *  Product: '<S21>/Divide3'

   *  Sum: '<S21>/Sum2'

   *  UnitDelay: '<S21>/UnitDelay1'

   */

  rtb_Sum3_idx_0 = 13107 * rtb_Sum1_tmp + rtDW->UnitDelay1_DSTATE[0];



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

   *  Interpolation_n-D: '<S23>/r_cos_M1'

   *  Interpolation_n-D: '<S23>/r_sin_M1'

   *  Product: '<S177>/Divide'

   *  Product: '<S177>/Divide4'

   *  Product: '<S22>/Divide1'

   *  Product: '<S22>/Divide4'

   */

  rtb_Sum1_tmp = ((rtb_Divide4 * rtConstP.r_cos_M1_Table[rtb_o_samp_p1]) >> 14)

    - ((rtb_Divide * rtConstP.r_sin_M1_Table[rtb_o_samp_p1]) >> 14);

  if (rtb_Sum1_tmp > 32767) {

    rtb_Sum1_tmp = 32767;

  } else {

    if (rtb_Sum1_tmp < -32768) {

      rtb_Sum1_tmp = -32768;

    }

  }



  /* Sum: '<S21>/Sum2' incorporates:

   *  Sum: '<S22>/Sum6'

   *  UnitDelay: '<S21>/UnitDelay1'

   */

  rtb_Sum1_tmp -= rtDW->UnitDelay1_DSTATE[1] >> 16;

  if (rtb_Sum1_tmp > 32767) {

    rtb_Sum1_tmp = 32767;

  } else {

    if (rtb_Sum1_tmp < -32768) {

      rtb_Sum1_tmp = -32768;

    }

  }



  /* Sum: '<S21>/Sum3' incorporates:

   *  Constant: '<S15>/Constant'

   *  Product: '<S21>/Divide3'

   *  Sum: '<S21>/Sum2'

   *  UnitDelay: '<S21>/UnitDelay1'

   */

  rtb_Sum3_idx_1 = 13107 * rtb_Sum1_tmp + rtDW->UnitDelay1_DSTATE[1];



  /* DataTypeConversion: '<S21>/Data Type Conversion' incorporates:

   *  Sum: '<S21>/Sum3'

   */

  rtb_Multiply_idx_0 = (int16_T)(rtb_Sum3_idx_0 >> 16);



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

   *  DiscreteIntegrator: '<S60>/Integrator'

   *  Gain: '<S65>/Proportional Gain'

   *  Signum: '<S51>/SignPreSat'

   *  Sum: '<S16>/Sum1'

   */

  rtb_Multiply_idx_1 = (int16_T)((((int16_T)(9 * (int16_T)-rtb_Multiply_idx_0) <<

    15) + (int32_T)((rtDW->Integrator_DSTATE * 1704243LL) >> 23)) >> 15);



  /* Saturate: '<S67>/Saturation' incorporates:

   *  Product: '<S177>/Divide'

   *  Signum: '<S51>/SignPreSat'

   */

  if (rtb_Multiply_idx_1 > 8960) {

    rtb_Divide = 8960;

  } else if (rtb_Multiply_idx_1 < -8960) {

    rtb_Divide = -8960;

  } else {

    rtb_Divide = rtb_Multiply_idx_1;

  }



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



  /* Sum: '<S16>/Sum3' incorporates:

   *  Inport: '<Root>/input_target'

   *  Inport: '<Root>/rotor_speed'

   */

  rtb_Sum3_l = (int16_T)(rtU_input_target - rtU_rotor_speed);



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

   *  DiscreteIntegrator: '<S160>/Integrator'

   *  Gain: '<S165>/Proportional Gain'

   *  Signum: '<S151>/SignPreSat'

   */

  rtb_SignPreSat = (int16_T)((rtDW->Integrator_DSTATE_i * 26629 < 0 ? -1 : 0) +

    (rtb_Sum3_l << 4));



  /* Saturate: '<S167>/Saturation' incorporates:

   *  Signum: '<S151>/SignPreSat'

   */

  if (rtb_SignPreSat > 800) {

    rtb_Divide4 = 800;

  } else if (rtb_SignPreSat < -800) {

    rtb_Divide4 = -800;

  } else {

    rtb_Divide4 = rtb_SignPreSat;

  }



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



  /* Sum: '<S16>/Sum2' incorporates:

   *  DataTypeConversion: '<S21>/Data Type Conversion'

   *  Sum: '<S21>/Sum3'

   */

  rtb_Sum2 = (int16_T)(rtb_Divide4 - (int16_T)(rtb_Sum3_idx_1 >> 16));



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

   *  DiscreteIntegrator: '<S110>/Integrator'

   *  Gain: '<S115>/Proportional Gain'

   *  Signum: '<S101>/SignPreSat'

   *  Sum: '<S16>/Sum2'

   */

  rtb_SignPreSat_k = (int16_T)((((int16_T)(10 * rtb_Sum2) << 15) + (int32_T)

    ((rtDW->Integrator_DSTATE_p * 1704243LL) >> 23)) >> 15);



  /* Saturate: '<S117>/Saturation' incorporates:

   *  Signum: '<S101>/SignPreSat'

   *  Signum: '<S51>/SignPreIntegrator'

   */

  if (rtb_SignPreSat_k > 8960) {

    rtb_SignPreIntegrator = 8960;

  } else if (rtb_SignPreSat_k < -8960) {

    rtb_SignPreIntegrator = -8960;

  } else {

    rtb_SignPreIntegrator = rtb_SignPreSat_k;

  }



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



  /* Sum: '<S18>/Sum1' incorporates:

   *  Interpolation_n-D: '<S23>/r_cos_M1'

   *  Interpolation_n-D: '<S23>/r_sin_M1'

   *  Product: '<S177>/Divide'

   *  Product: '<S18>/Divide2'

   *  Product: '<S18>/Divide3'

   *  Signum: '<S51>/SignPreIntegrator'

   */

  rtb_Sum1_tmp = ((rtb_Divide * rtConstP.r_sin_M1_Table[rtb_o_samp_p1]) >> 14) +

    ((rtb_SignPreIntegrator * rtConstP.r_cos_M1_Table[rtb_o_samp_p1]) >> 14);

  if (rtb_Sum1_tmp > 32767) {

    rtb_Sum1_tmp = 32767;

  } else {

    if (rtb_Sum1_tmp < -32768) {

      rtb_Sum1_tmp = -32768;

    }

  }



  /* Sum: '<S18>/Sum6' incorporates:

   *  Interpolation_n-D: '<S23>/r_cos_M1'

   *  Interpolation_n-D: '<S23>/r_sin_M1'

   *  Product: '<S177>/Divide'

   *  Product: '<S18>/Divide1'

   *  Product: '<S18>/Divide4'

   *  Signum: '<S51>/SignPreIntegrator'

   */

  tmp_0 = ((rtb_Divide * rtConstP.r_cos_M1_Table[rtb_o_samp_p1]) >> 14) -

    ((rtb_SignPreIntegrator * rtConstP.r_sin_M1_Table[rtb_o_samp_p1]) >> 14);

  if (tmp_0 > 32767) {

    tmp_0 = 32767;

  } else {

    if (tmp_0 < -32768) {

      tmp_0 = -32768;

    }

  }



  /* Product: '<S177>/Divide7' incorporates:

   *  Constant: '<S177>/Constant3'

   *  Sum: '<S18>/Sum1'

   */

  rtb_Divide7 = (int16_T)((2365 * (int16_T)rtb_Sum1_tmp) >> 10);



  /* MATLAB Function: '<S177>/sector_select' incorporates:

   *  Product: '<S177>/Divide7'

   *  Sum: '<S18>/Sum1'

   *  Sum: '<S18>/Sum6'

   */

  if ((int16_T)rtb_Sum1_tmp >= 0) {

    if ((int16_T)tmp_0 >= 0) {

      if (rtb_Divide7 > ((int16_T)tmp_0 << 2)) {

        /* DataTypeConversion: '<S177>/Data Type Conversion' */

        rtb_DataTypeConversion_a = 2U;

      } else {

        /* DataTypeConversion: '<S177>/Data Type Conversion' */

        rtb_DataTypeConversion_a = 1U;

      }

    } else {

      tmp = -rtb_Divide7;

      if (-rtb_Divide7 > 32767) {

        tmp = 32767;

      }



      if (tmp > ((int16_T)tmp_0 << 2)) {

        /* DataTypeConversion: '<S177>/Data Type Conversion' */

        rtb_DataTypeConversion_a = 3U;

      } else {

        /* DataTypeConversion: '<S177>/Data Type Conversion' */

        rtb_DataTypeConversion_a = 2U;

      }

    }

  } else if ((int16_T)tmp_0 >= 0) {

    tmp = -rtb_Divide7;

    if (-rtb_Divide7 > 32767) {

      tmp = 32767;

    }



    if (tmp > ((int16_T)tmp_0 << 2)) {

      /* DataTypeConversion: '<S177>/Data Type Conversion' */

      rtb_DataTypeConversion_a = 5U;

    } else {

      /* DataTypeConversion: '<S177>/Data Type Conversion' */

      rtb_DataTypeConversion_a = 6U;

    }

  } else if (rtb_Divide7 > ((int16_T)tmp_0 << 2)) {

    /* DataTypeConversion: '<S177>/Data Type Conversion' */

    rtb_DataTypeConversion_a = 4U;

  } else {

    /* DataTypeConversion: '<S177>/Data Type Conversion' */

    rtb_DataTypeConversion_a = 5U;

  }



  /* End of MATLAB Function: '<S177>/sector_select' */



  /* Product: '<S177>/Divide' incorporates:

   *  DataTypeConversion: '<S177>/Data Type Conversion6'

   *  Inport: '<Root>/Ts'

   *  Inport: '<Root>/Vdc'

   */

  rtb_Divide = (int16_T)div_nde_s32_floor((int16_T)rtU_Ts << 10, rtU_Vdc);



  /* Product: '<S177>/Divide8' incorporates:

   *  Constant: '<S177>/Constant'

   *  Product: '<S177>/Divide2'

   *  Product: '<S177>/Divide4'

   *  Sum: '<S18>/Sum1'

   */

  rtb_Sum1_tmp = 2365 * (int16_T)((3547 * (int16_T)rtb_Sum1_tmp) >> 10);



  /* Product: '<S177>/Divide1' incorporates:

   *  Product: '<S177>/Divide'

   *  Product: '<S177>/Divide8'

   */

  rtb_Sum1 = (int16_T)(((int16_T)(rtb_Sum1_tmp >> 11) * rtb_Divide) >> 12);



  /* Product: '<S177>/Divide3' incorporates:

   *  Constant: '<S177>/Constant1'

   *  Signum: '<S51>/SignPreIntegrator'

   *  Sum: '<S18>/Sum6'

   */

  rtb_SignPreIntegrator = (int16_T)((3547 * (int16_T)tmp_0) >> 10);



  /* Product: '<S177>/Divide4' */

  rtb_Divide4 = (int16_T)(rtb_Sum1_tmp >> 12);



  /* Product: '<S177>/Divide5' incorporates:

   *  Product: '<S177>/Divide'

   *  Product: '<S177>/Divide4'

   *  Signum: '<S51>/SignPreIntegrator'

   *  Sum: '<S177>/Add'

   */

  rtb_Divide7 = (int16_T)(((int16_T)(rtb_SignPreIntegrator + rtb_Divide4) *

    rtb_Divide) >> 12);



  /* Product: '<S177>/Divide6' incorporates:

   *  Product: '<S177>/Divide'

   *  Product: '<S177>/Divide4'

   *  Signum: '<S51>/SignPreIntegrator'

   *  Sum: '<S177>/Add1'

   */

  rtb_SignPreIntegrator = (int16_T)(((int16_T)(rtb_Divide4 -

    rtb_SignPreIntegrator) * rtb_Divide) >> 12);



  /* MATLAB Function: '<S177>/phase_time' incorporates:

   *  DataTypeConversion: '<S177>/Data Type Conversion1'

   *  DataTypeConversion: '<S177>/Data Type Conversion2'

   *  Inport: '<Root>/Ts'

   */

  switch ((int8_T)rtb_DataTypeConversion_a) {

   case 1:

    rtb_Sum1_tmp = -rtb_SignPreIntegrator;

    if (-rtb_SignPreIntegrator > 32767) {

      rtb_Sum1_tmp = 32767;

    }



    tmp_0 = (int16_T)rtU_Ts - (int16_T)rtb_Sum1_tmp;

    if (tmp_0 > 32767) {

      tmp_0 = 32767;

    } else {

      if (tmp_0 < -32768) {

        tmp_0 = -32768;

      }

    }



    tmp_0 -= rtb_Sum1;

    if (tmp_0 > 32767) {

      tmp_0 = 32767;

    } else {

      if (tmp_0 < -32768) {

        tmp_0 = -32768;

      }

    }



    rtb_Divide = (int16_T)rt_roundd_snf((real_T)tmp_0 / 4.0);

    rtb_Sum1 = (int16_T)((int32_T)rt_roundd_snf((real_T)rtb_Sum1 / 2.0) +

                         rtb_Divide);

    rtb_Sum1_tmp = (int32_T)rt_roundd_snf((real_T)(int16_T)rtb_Sum1_tmp / 2.0) +

      rtb_Sum1;

    if (rtb_Sum1_tmp > 32767) {

      rtb_Sum1_tmp = 32767;

    } else {

      if (rtb_Sum1_tmp < -32768) {

        rtb_Sum1_tmp = -32768;

      }

    }



    rtb_Divide7 = (int16_T)rtb_Sum1_tmp;

    break;



   case 2:

    rtb_Sum1_tmp = (int16_T)rtU_Ts - rtb_Divide7;

    if (rtb_Sum1_tmp > 32767) {

      rtb_Sum1_tmp = 32767;

    } else {

      if (rtb_Sum1_tmp < -32768) {

        rtb_Sum1_tmp = -32768;

      }

    }



    rtb_Sum1_tmp -= rtb_SignPreIntegrator;

    if (rtb_Sum1_tmp > 32767) {

      rtb_Sum1_tmp = 32767;

    } else {

      if (rtb_Sum1_tmp < -32768) {

        rtb_Sum1_tmp = -32768;

      }

    }



    rtb_Divide = (int16_T)rt_roundd_snf((real_T)rtb_Sum1_tmp / 4.0);

    rtb_Divide7 = (int16_T)((int32_T)rt_roundd_snf((real_T)rtb_Divide7 / 2.0) +

      rtb_Divide);

    rtb_Sum1_tmp = (int32_T)rt_roundd_snf((real_T)rtb_SignPreIntegrator / 2.0) +

      rtb_Divide7;

    if (rtb_Sum1_tmp > 32767) {

      rtb_Sum1_tmp = 32767;

    } else {

      if (rtb_Sum1_tmp < -32768) {

        rtb_Sum1_tmp = -32768;

      }

    }



    rtb_Sum1 = (int16_T)rtb_Sum1_tmp;

    break;



   case 3:

    rtb_Sum1_tmp = -rtb_Divide7;

    if (-rtb_Divide7 > 32767) {

      rtb_Sum1_tmp = 32767;

    }



    tmp_0 = (int16_T)rtU_Ts - rtb_Sum1;

    if (tmp_0 > 32767) {

      tmp_0 = 32767;

    } else {

      if (tmp_0 < -32768) {

        tmp_0 = -32768;

      }

    }



    tmp_0 -= (int16_T)rtb_Sum1_tmp;

    if (tmp_0 > 32767) {

      tmp_0 = 32767;

    } else {

      if (tmp_0 < -32768) {

        tmp_0 = -32768;

      }

    }



    rtb_Divide7 = (int16_T)rt_roundd_snf((real_T)tmp_0 / 4.0);

    rtb_Divide = (int16_T)((int32_T)rt_roundd_snf((real_T)(int16_T)rtb_Sum1_tmp /

      2.0) + rtb_Divide7);

    rtb_Sum1_tmp = (int32_T)rt_roundd_snf((real_T)rtb_Sum1 / 2.0) + rtb_Divide;

    if (rtb_Sum1_tmp > 32767) {

      rtb_Sum1_tmp = 32767;

    } else {

      if (rtb_Sum1_tmp < -32768) {

        rtb_Sum1_tmp = -32768;

      }

    }



    rtb_Sum1 = (int16_T)rtb_Sum1_tmp;

    break;



   case 4:

    rtb_Sum1_tmp = -rtb_Sum1;

    if (-rtb_Sum1 > 32767) {

      rtb_Sum1_tmp = 32767;

    }



    tmp_0 = (int16_T)rtU_Ts - (int16_T)rtb_Sum1_tmp;

    if (tmp_0 > 32767) {

      tmp_0 = 32767;

    } else {

      if (tmp_0 < -32768) {

        tmp_0 = -32768;

      }

    }



    tmp_0 -= rtb_SignPreIntegrator;

    if (tmp_0 > 32767) {

      tmp_0 = 32767;

    } else {

      if (tmp_0 < -32768) {

        tmp_0 = -32768;

      }

    }



    rtb_Divide7 = (int16_T)rt_roundd_snf((real_T)tmp_0 / 4.0);

    rtb_Sum1 = (int16_T)((int32_T)rt_roundd_snf((real_T)rtb_SignPreIntegrator /

      2.0) + rtb_Divide7);

    rtb_Sum1_tmp = (int32_T)rt_roundd_snf((real_T)(int16_T)rtb_Sum1_tmp / 2.0) +

      rtb_Sum1;

    if (rtb_Sum1_tmp > 32767) {

      rtb_Sum1_tmp = 32767;

    } else {

      if (rtb_Sum1_tmp < -32768) {

        rtb_Sum1_tmp = -32768;

      }

    }



    rtb_Divide = (int16_T)rtb_Sum1_tmp;

    break;



   case 5:

    rtb_Sum1_tmp = -rtb_Divide7;

    if (-rtb_Divide7 > 32767) {

      rtb_Sum1_tmp = 32767;

    }



    tmp_0 = -rtb_SignPreIntegrator;

    if (-rtb_SignPreIntegrator > 32767) {

      tmp_0 = 32767;

    }



    tmp = (int16_T)rtU_Ts - (int16_T)rtb_Sum1_tmp;

    if (tmp > 32767) {

      tmp = 32767;

    } else {

      if (tmp < -32768) {

        tmp = -32768;

      }

    }



    tmp -= (int16_T)tmp_0;

    if (tmp > 32767) {

      tmp = 32767;

    } else {

      if (tmp < -32768) {

        tmp = -32768;

      }

    }



    rtb_Sum1 = (int16_T)rt_roundd_snf((real_T)tmp / 4.0);

    rtb_Divide7 = (int16_T)((int32_T)rt_roundd_snf((real_T)(int16_T)tmp_0 / 2.0)

      + rtb_Sum1);

    rtb_Sum1_tmp = (int32_T)rt_roundd_snf((real_T)(int16_T)rtb_Sum1_tmp / 2.0) +

      rtb_Divide7;

    if (rtb_Sum1_tmp > 32767) {

      rtb_Sum1_tmp = 32767;

    } else {

      if (rtb_Sum1_tmp < -32768) {

        rtb_Sum1_tmp = -32768;

      }

    }



    rtb_Divide = (int16_T)rtb_Sum1_tmp;

    break;



   default:

    rtb_Sum1_tmp = -rtb_Sum1;

    if (-rtb_Sum1 > 32767) {

      rtb_Sum1_tmp = 32767;

    }



    tmp_0 = (int16_T)rtU_Ts - rtb_Divide7;

    if (tmp_0 > 32767) {

      tmp_0 = 32767;

    } else {

      if (tmp_0 < -32768) {

        tmp_0 = -32768;

      }

    }



    tmp_0 -= (int16_T)rtb_Sum1_tmp;

    if (tmp_0 > 32767) {

      tmp_0 = 32767;

    } else {

      if (tmp_0 < -32768) {

        tmp_0 = -32768;

      }

    }



    rtb_Sum1 = (int16_T)rt_roundd_snf((real_T)tmp_0 / 4.0);

    rtb_Divide = (int16_T)((int32_T)rt_roundd_snf((real_T)(int16_T)rtb_Sum1_tmp /

      2.0) + rtb_Sum1);

    rtb_Sum1_tmp = (int32_T)rt_roundd_snf((real_T)rtb_Divide7 / 2.0) +

      rtb_Divide;

    if (rtb_Sum1_tmp > 32767) {

      rtb_Sum1_tmp = 32767;

    } else {

      if (rtb_Sum1_tmp < -32768) {

        rtb_Sum1_tmp = -32768;

      }

    }



    rtb_Divide7 = (int16_T)rtb_Sum1_tmp;

    break;

  }



  /* DataTypeConversion: '<S177>/Data Type Conversion3' incorporates:

   *  MATLAB Function: '<S177>/phase_time'

   */

  rtb_DataTypeConversion3 = (uint16_T)rtb_Divide7;



  /* MultiPortSwitch: '<S178>/Multiport Switch' incorporates:

   *  DataTypeConversion: '<S177>/Data Type Conversion3'

   *  DataTypeConversion: '<S177>/Data Type Conversion4'

   *  DataTypeConversion: '<S177>/Data Type Conversion5'

   *  MATLAB Function: '<S177>/phase_time'

   */

  switch (rtb_DataTypeConversion_a) {

   case 1:

    rtb_MultiportSwitch_idx_0 = (uint16_T)rtb_Divide7;

    rtb_MultiportSwitch_idx_1 = (uint16_T)rtb_Sum1;

    break;



   case 2:

    rtb_MultiportSwitch_idx_0 = (uint16_T)rtb_Sum1;

    rtb_MultiportSwitch_idx_1 = (uint16_T)rtb_Divide7;

    break;



   case 3:

    rtb_MultiportSwitch_idx_0 = (uint16_T)rtb_Sum1;

    rtb_MultiportSwitch_idx_1 = (uint16_T)rtb_Divide;

    break;



   case 4:

    rtb_MultiportSwitch_idx_0 = (uint16_T)rtb_Divide;

    rtb_MultiportSwitch_idx_1 = (uint16_T)rtb_Sum1;

    break;



   case 5:

    rtb_MultiportSwitch_idx_0 = (uint16_T)rtb_Divide;

    rtb_MultiportSwitch_idx_1 = (uint16_T)rtb_Divide7;

    break;



   default:

    rtb_MultiportSwitch_idx_0 = (uint16_T)rtb_Divide7;

    rtb_MultiportSwitch_idx_1 = (uint16_T)rtb_Divide;

    break;

  }



  /* End of MultiPortSwitch: '<S178>/Multiport Switch' */



  /* Outport: '<Root>/pwm_counts' incorporates:

   *  Constant: '<S178>/Constant'

   *  Constant: '<S178>/Constant1'

   *  Constant: '<S178>/Constant2'

   *  Constant: '<S178>/Constant3'

   *  MATLAB Function: '<S178>/Shunt_Three_Sample_Point'

   *  Outport: '<Root>/sector'

   */

  Shunt_Three_Sample_Point(rtb_MultiportSwitch_idx_0, rtb_MultiportSwitch_idx_1,

    rtb_DataTypeConversion_a, 4000, 10, 10, 10, &rtb_o_samp_p1, &rtY_pwm_counts

    [7], rtY_sector);



  /* DeadZone: '<S103>/DeadZone' incorporates:

   *  Signum: '<S101>/SignPreSat'

   */

  if (rtb_SignPreSat_k > 8960) {

    rtb_SignPreSat_k = (int16_T)(rtb_SignPreSat_k - 8960);

  } else if (rtb_SignPreSat_k >= -8960) {

    rtb_SignPreSat_k = 0;

  } else {

    rtb_SignPreSat_k = (int16_T)(rtb_SignPreSat_k - -8960);

  }



  /* End of DeadZone: '<S103>/DeadZone' */



  /* RelationalOperator: '<S101>/NotEqual' incorporates:

   *  Gain: '<S101>/ZeroGain'

   *  Signum: '<S101>/SignPreSat'

   */

  rtb_NotEqual = (0 != rtb_SignPreSat_k);



  /* Signum: '<S101>/SignPreSat' */

  if (rtb_SignPreSat_k < 0) {

    rtb_SignPreSat_k = -1;

  } else {

    rtb_SignPreSat_k = (int16_T)(rtb_SignPreSat_k > 0);

  }



  /* End of Signum: '<S101>/SignPreSat' */



  /* Gain: '<S107>/Integral Gain' incorporates:

   *  Gain: '<S57>/Integral Gain'

   *  Sum: '<S16>/Sum2'

   */

  rtb_Divide7 = (int16_T)(1080 * rtb_Sum2);



  /* Signum: '<S101>/SignPreIntegrator' incorporates:

   *  Gain: '<S57>/Integral Gain'

   */

  if (rtb_Divide7 < 0) {

    rtb_Divide4 = -1;

  } else {

    rtb_Divide4 = (int16_T)(rtb_Divide7 > 0);

  }



  /* End of Signum: '<S101>/SignPreIntegrator' */



  /* Switch: '<S101>/Switch' incorporates:

   *  Constant: '<S101>/Constant1'

   *  DataTypeConversion: '<S101>/DataTypeConv1'

   *  DataTypeConversion: '<S101>/DataTypeConv2'

   *  Gain: '<S57>/Integral Gain'

   *  Logic: '<S101>/AND3'

   *  RelationalOperator: '<S101>/Equal1'

   */

  if (rtb_NotEqual && (rtb_SignPreSat_k == rtb_Divide4)) {

    rtb_Sum2 = 0;

  } else {

    rtb_Sum2 = rtb_Divide7;

  }



  /* End of Switch: '<S101>/Switch' */



  /* DeadZone: '<S153>/DeadZone' incorporates:

   *  Signum: '<S151>/SignPreSat'

   */

  if (rtb_SignPreSat > 800) {

    rtb_SignPreSat = (int16_T)(rtb_SignPreSat - 800);

  } else if (rtb_SignPreSat >= -800) {

    rtb_SignPreSat = 0;

  } else {

    rtb_SignPreSat = (int16_T)(rtb_SignPreSat - -800);

  }



  /* End of DeadZone: '<S153>/DeadZone' */



  /* RelationalOperator: '<S151>/NotEqual' incorporates:

   *  Gain: '<S151>/ZeroGain'

   *  Signum: '<S151>/SignPreSat'

   */

  rtb_NotEqual = (0 != rtb_SignPreSat);



  /* Signum: '<S151>/SignPreSat' */

  if (rtb_SignPreSat < 0) {

    rtb_SignPreSat = -1;

  } else {

    rtb_SignPreSat = (int16_T)(rtb_SignPreSat > 0);

  }



  /* End of Signum: '<S151>/SignPreSat' */



  /* Gain: '<S157>/Integral Gain' incorporates:

   *  Gain: '<S57>/Integral Gain'

   */

  rtb_Divide7 = (int16_T)((int16_T)(200 * rtb_Sum3_l) << 4);



  /* Signum: '<S151>/SignPreIntegrator' incorporates:

   *  Gain: '<S57>/Integral Gain'

   */

  if (rtb_Divide7 < 0) {

    rtb_Divide4 = -1;

  } else {

    rtb_Divide4 = (int16_T)(rtb_Divide7 > 0);

  }



  /* End of Signum: '<S151>/SignPreIntegrator' */



  /* Switch: '<S151>/Switch' incorporates:

   *  Constant: '<S151>/Constant1'

   *  DataTypeConversion: '<S151>/DataTypeConv1'

   *  DataTypeConversion: '<S151>/DataTypeConv2'

   *  Gain: '<S57>/Integral Gain'

   *  Logic: '<S151>/AND3'

   *  RelationalOperator: '<S151>/Equal1'

   */

  if (rtb_NotEqual && (rtb_SignPreSat == rtb_Divide4)) {

    rtb_Sum3_l = 0;

  } else {

    rtb_Sum3_l = rtb_Divide7;

  }



  /* End of Switch: '<S151>/Switch' */



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

   *  Signum: '<S51>/SignPreSat'

   */

  if (rtb_Multiply_idx_1 > 8960) {

    rtb_Multiply_idx_1 = (int16_T)(rtb_Multiply_idx_1 - 8960);

  } else if (rtb_Multiply_idx_1 >= -8960) {

    rtb_Multiply_idx_1 = 0;

  } else {

    rtb_Multiply_idx_1 = (int16_T)(rtb_Multiply_idx_1 - -8960);

  }



  /* End of DeadZone: '<S53>/DeadZone' */



  /* RelationalOperator: '<S51>/NotEqual' incorporates:

   *  Gain: '<S51>/ZeroGain'

   *  Signum: '<S51>/SignPreSat'

   */

  rtb_NotEqual = (0 != rtb_Multiply_idx_1);



  /* Signum: '<S51>/SignPreSat' */

  if (rtb_Multiply_idx_1 < 0) {

    rtb_Multiply_idx_1 = -1;

  } else {

    rtb_Multiply_idx_1 = (int16_T)(rtb_Multiply_idx_1 > 0);

  }



  /* End of Signum: '<S51>/SignPreSat' */



  /* Gain: '<S57>/Integral Gain' incorporates:

   *  Sum: '<S16>/Sum1'

   */

  rtb_Divide7 = (int16_T)(1071 * (int16_T)-rtb_Multiply_idx_0);



  /* Update for UnitDelay: '<S21>/UnitDelay1' incorporates:

   *  Sum: '<S21>/Sum3'

   */

  rtDW->UnitDelay1_DSTATE[0] = rtb_Sum3_idx_0;

  rtDW->UnitDelay1_DSTATE[1] = rtb_Sum3_idx_1;



  /* Signum: '<S51>/SignPreIntegrator' incorporates:

   *  Gain: '<S57>/Integral Gain'

   */

  if (rtb_Divide7 < 0) {

    rtb_Divide4 = -1;

  } else {

    rtb_Divide4 = (int16_T)(rtb_Divide7 > 0);

  }



  /* End of Signum: '<S51>/SignPreIntegrator' */



  /* Switch: '<S51>/Switch' incorporates:

   *  Constant: '<S51>/Constant1'

   *  DataTypeConversion: '<S51>/DataTypeConv1'

   *  DataTypeConversion: '<S51>/DataTypeConv2'

   *  Logic: '<S51>/AND3'

   *  RelationalOperator: '<S51>/Equal1'

   */

  if (rtb_NotEqual && (rtb_Multiply_idx_1 == rtb_Divide4)) {

    rtb_Divide7 = 0;

  }



  /* End of Switch: '<S51>/Switch' */



  /* Update for DiscreteIntegrator: '<S60>/Integrator' */

  rtDW->Integrator_DSTATE += rtb_Divide7;



  /* Update for DiscreteIntegrator: '<S160>/Integrator' incorporates:

   *  Switch: '<S151>/Switch'

   */

  rtDW->Integrator_DSTATE_i += rtb_Sum3_l;



  /* Update for DiscreteIntegrator: '<S110>/Integrator' incorporates:

   *  Switch: '<S101>/Switch'

   */

  rtDW->Integrator_DSTATE_p += rtb_Sum2;



  /* End of Outputs for SubSystem: '<S1>/controller' */



  /* Outport: '<Root>/pwm_counts' incorporates:

   *  DataTypeConversion: '<S177>/Data Type Conversion4'

   *  DataTypeConversion: '<S177>/Data Type Conversion5'

   *  MATLAB Function: '<S177>/phase_time'

   */

  rtY_pwm_counts[0] = rtb_DataTypeConversion3;



  /* Outputs for Atomic SubSystem: '<S1>/controller' */

  rtY_pwm_counts[1] = (uint16_T)rtb_Sum1;

  rtY_pwm_counts[2] = (uint16_T)rtb_Divide;



  /* End of Outputs for SubSystem: '<S1>/controller' */

  rtY_pwm_counts[3] = rtb_DataTypeConversion3;



  /* Outputs for Atomic SubSystem: '<S1>/controller' */

  rtY_pwm_counts[4] = (uint16_T)rtb_Sum1;

  rtY_pwm_counts[5] = (uint16_T)rtb_Divide;



  /* End of Outputs for SubSystem: '<S1>/controller' */

  rtY_pwm_counts[6] = rtb_o_samp_p1;

  rate_scheduler(rtM);

}



/* Model initialize function */

void PMSM_Controller_initialize(RT_MODEL *const rtM)

{

  /* Registration code */



  /* initialize non-finites */

  rt_InitInfAndNaN(sizeof(real_T));

  UNUSED_PARAMETER(rtM);

}



/*

 * File trailer for generated code.

 *

 * [EOF]

 */