1



2



3    /*



4  * rt_nonfinite.c



5  *



6    * Code generation for model "PMSM_Motor_TL3_sf".



7  *



8  * Model version              : 1.825



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



10  * C source code generated on : Fri Apr 14 12:51:02 2023



11 * 



12 * Target selection: rtwsfcn.tlc



13 * Note: GRT includes extra infrastructure and instrumentation for prototyping



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



15 * Emulation hardware selection: 



16 *    Differs from embedded hardware (MATLAB Host)



17 * Code generation objectives: 



18 *    1. Execution efficiency



19 *    2. RAM efficiency



20 * Validation result: Not run



21  */



22



23



24



25    



26



27    /*



28  * Abstract:



29  *      Function to initialize non-finites,



30  *      (Inf, NaN and -Inf).



31  */



32    #include "rt_nonfinite.h"



33



34          #include "rtGetNaN.h"



35      



36        #include "rtGetInf.h"



37      



38    



39



40    



41



42



43  



44



45  



46



47  



48



49    #define NumBitsPerChar  8U



50



51



52  



53



54  



55



56  



57



58  



59



60  



61



62  



63



64  



65



66  



67



68  



69



70  



71



72  



73



74  



75



76



77  real_T rtInf;



78



79



80  



81



82



83  real_T rtMinusInf;



84



85



86  



87



88



89  real_T rtNaN;



90



91



92  



93



94



95  real32_T rtInfF;



96



97



98  



99



100



101  real32_T rtMinusInfF;



102



103



104  



105



106



107  real32_T rtNaNF;



108



109



110



111



112



113    



114  /* 



115 * Initialize the rtInf, rtMinusInf, and rtNaN needed by the



116 * generated code. NaN is initialized as non-signaling. Assumes IEEE.



117 */



118



119     void rt_InitInfAndNaN(size_t realSize) {



120



121    (void) (realSize); 



122    rtNaN = rtGetNaN();



123    rtNaNF = rtGetNaNF();



124    rtInf = rtGetInf();



125    rtInfF = rtGetInfF();



126    rtMinusInf = rtGetMinusInf();



127    rtMinusInfF = rtGetMinusInfF();



128  }



129    



130  /* Test if value is infinite */



131     boolean_T rtIsInf(real_T value) {



132    return (boolean_T)((value==rtInf || value==rtMinusInf) ? 1U : 0U);



133  }



134    



135  /* Test if single-precision value is infinite */



136     boolean_T rtIsInfF(real32_T value) {



137    return (boolean_T)(((value)==rtInfF || (value)==rtMinusInfF) ? 1U : 0U);



138  }



139    



140  /* Test if value is not a number */



141     boolean_T rtIsNaN(real_T value) {



142    boolean_T result = (boolean_T) 0;



143    size_t bitsPerReal = sizeof(real_T) * (NumBitsPerChar);



144    



145    if (bitsPerReal == 32U) {



146      result = rtIsNaNF((real32_T)value);



147    } else {



148          



149  union {



150    LittleEndianIEEEDouble bitVal;



151    real_T fltVal;



152  } tmpVal;



153  tmpVal.fltVal = value;



154  result = (boolean_T)((tmpVal.bitVal.words.wordH & 0x7FF00000) == 0x7FF00000 &&



155                       ( (tmpVal.bitVal.words.wordH & 0x000FFFFF) != 0 ||



156                         (tmpVal.bitVal.words.wordL != 0) ));



157



158



159    }



160    return result;



161  }



162    



163  /* Test if single-precision value is not a number */



164     boolean_T rtIsNaNF(real32_T value) {



165    IEEESingle tmp;



166    tmp.wordL.wordLreal = value;



167    return (boolean_T)( (tmp.wordL.wordLuint & 0x7F800000) == 0x7F800000 &&



168                        (tmp.wordL.wordLuint & 0x007FFFFF) != 0 );



169  }



170    



171



172



173  



174



175  



176



177  



178



179  



180