File: C:\MATLAB\work\fadingchannelconstructed_grt_rtw/fadingchannelconstructed.c1 /* 2 * Real-Time Workshop code generation for Simulink model "fadingchannelconstructed.mdl". 3 * 4 * Model Version : 1.39 5 * Real-Time Workshop file version : 5.0 $Date: 2002/05/30 19:21:33 $ 6 * Real-Time Workshop file generated on : Wed Mar 17 14:58:13 2004 7 * TLC version : 5.0 (Jun 18 2002) 8 * C source code generated on : Wed Mar 17 14:58:13 2004 9 */ 10 11 #include <math.h> 12 #include <string.h> 13 #include "fadingchannelconstructed.h" 14 #include "fadingchannelconstructed_private.h" 15 16 /* Block signals (auto storage) */ 17 BlockIO rtB; 18 19 /* Block states (auto storage) */ 20 D_Work rtDWork; 21 22 /* Parent Simstruct */ 23 static rtModel_fadingchannelconstructed model_S; 24 rtModel_fadingchannelconstructed *const rtM_fadingchannelconstructed = &model_S; 25 26 /* Initial conditions for root system: '<Root>' */ 27 void MdlInitialize(void) 28 { 29 30 /* DSP Blockset Delay (sdspdly2) - '<S1>/Integer Delay' */ 31 rtDWork.Integer_Delay_BUFF_OFFSET = 49; 32 MWDSP_DelayCopyScalarICs( (byte_T *)&rtDWork.Integer_Delay_BUFF[0], (byte_T 33 *)&rtP.Integer_Delay_IC, 1*51, sizeof(real_T) ); 34 35 /* DSP Blockset Filter Implementation (sdspfilter) - '<S5>/Direct-Form II Transpose Filter' */ 36 { 37 real_T *statePtr = (real_T *) &rtDWork.Direct_Form_II_Tran_FILT_STATES[0]; 38 /* Scalar expansion of ICs with extra zero element per channel */ 39 int_T numElems = 100; 40 while (numElems--) { 41 *statePtr++ = *(const real_T *)&rtP.Direct_Form_II_Tran_ICRTP; 42 } 43 *statePtr = 0.0; 44 } 45 } 46 47 /* Start for root system: '<Root>' */ 48 void MdlStart(void) 49 { 50 51 /* RandomNumber Block: <S2>/Random Number */ 52 { 53 uint_T *RandSeed = (uint_T *) &rtDWork.Random_Number_a_IWORK.RandSeed; 54 int_T r, t; 55 *RandSeed = 41U; 56 r = *RandSeed >> 16; 57 t = *RandSeed & BIT16; 58 *RandSeed = ((*RandSeed - (r << 16) - t) << 16) + t + r; 59 if (*RandSeed < 1) { 60 *RandSeed = SEED0; 61 } 62 if (*RandSeed > MAXSEED) { 63 *RandSeed = MAXSEED; 64 } 65 66 rtDWork.Random_Number_a_RWORK.NextOutput = 67 rt_NormalRand(RandSeed++) * rtP.Random_Number_a_StdDev + 68 rtP.Random_Number_a_Mean; 69 } 70 71 /* DiscretePulseGenerator Block: <Root>/Pulse Generator */ 72 { 73 int_T Ns; 74 real_T tFirst = rtmGetTStart(rtM_fadingchannelconstructed); 75 Ns = (int_T)floor(tFirst / 0.0002 + 0.5); 76 if (Ns <= 0) { 77 rtDWork.Pulse_Generator_IWORK.ClockTicksCounter = Ns; 78 } else { 79 rtDWork.Pulse_Generator_IWORK.ClockTicksCounter = Ns - 80 (int_T)(rtP.Pulse_Generator_Period*floor((real_T)Ns / 81 rtP.Pulse_Generator_Period)); 82 } 83 } 84 85 /* RandomNumber Block: <S3>/Random Number */ 86 { 87 uint_T *RandSeed = (uint_T *) &rtDWork.Random_Number_b_IWORK.RandSeed; 88 int_T r, t; 89 *RandSeed = 41U; 90 r = *RandSeed >> 16; 91 t = *RandSeed & BIT16; 92 *RandSeed = ((*RandSeed - (r << 16) - t) << 16) + t + r; 93 if (*RandSeed < 1) { 94 *RandSeed = SEED0; 95 } 96 if (*RandSeed > MAXSEED) { 97 *RandSeed = MAXSEED; 98 } 99 100 rtDWork.Random_Number_b_RWORK.NextOutput = 101 rt_NormalRand(RandSeed++) * rtP.Random_Number_b_StdDev + 102 rtP.Random_Number_b_Mean; 103 } 104 105 /* ToWorkspace Block: <Root>/To Workspace */ 106 { 107 static const int_T rt_ToWksWidths[] = {1}; 108 static const int_T rt_ToWksNumDimensions[] = {1}; 109 static const int_T rt_ToWksDimensions[] = {1}; 110 static const BuiltInDTypeId rt_ToWksDataTypeIds[] = {SS_DOUBLE}; 111 static const int_T rt_ToWksComplexSignals[] = {0}; 112 static const int_T rt_ToWksFrameData[] = {0}; 113 static const char_T rt_ToWksLabels[] = ""; 114 static const RTWLogSignalInfo rt_ToWksSignalInfo = { 115 1, 116 rt_ToWksWidths, 117 rt_ToWksNumDimensions, 118 rt_ToWksDimensions, 119 rt_ToWksDataTypeIds, 120 rt_ToWksComplexSignals, 121 rt_ToWksFrameData, 122 rt_ToWksLabels, 123 NULL, 124 NULL, 125 NULL, 126 NULL, 127 NULL, 128 NULL 129 }; 130 static const char_T rt_ToWksBlockName[] = 131 "fadingchannelconstructed/To Workspace"; 132 133 rtDWork.To_Workspace_PWORK.LoggedData = 134 rt_CreateStructLogVar(rtM_fadingchannelconstructed->rtwLogInfo, 135 rtM_fadingchannelconstructed->Timing.tFinal, 136 rtM_fadingchannelconstructed->Timing.stepSize, 137 &(rtmGetErrorStatus(rtM_fadingchannelconstructed)), "RayleighPDFOutput", 138 0, 0, 1, 0.0002, &rt_ToWksSignalInfo, rt_ToWksBlockName); 139 140 if (rtDWork.To_Workspace_PWORK.LoggedData == NULL) return; 141 } 142 143 /* ToWorkspace Block: <Root>/To Workspace1 */ 144 { 145 static const int_T rt_ToWksWidths[] = {1}; 146 static const int_T rt_ToWksNumDimensions[] = {1}; 147 static const int_T rt_ToWksDimensions[] = {1}; 148 static const BuiltInDTypeId rt_ToWksDataTypeIds[] = {SS_DOUBLE}; 149 static const int_T rt_ToWksComplexSignals[] = {0}; 150 static const int_T rt_ToWksFrameData[] = {0}; 151 static const char_T rt_ToWksLabels[] = ""; 152 static const RTWLogSignalInfo rt_ToWksSignalInfo = { 153 1, 154 rt_ToWksWidths, 155 rt_ToWksNumDimensions, 156 rt_ToWksDimensions, 157 rt_ToWksDataTypeIds, 158 rt_ToWksComplexSignals, 159 rt_ToWksFrameData, 160 rt_ToWksLabels, 161 NULL, 162 NULL, 163 NULL, 164 NULL, 165 NULL, 166 NULL 167 }; 168 static const char_T rt_ToWksBlockName[] = 169 "fadingchannelconstructed/To Workspace1"; 170 171 rtDWork.To_Workspace1_PWORK.LoggedData = 172 rt_CreateStructLogVar(rtM_fadingchannelconstructed->rtwLogInfo, 173 rtM_fadingchannelconstructed->Timing.tFinal, 174 rtM_fadingchannelconstructed->Timing.stepSize, 175 &(rtmGetErrorStatus(rtM_fadingchannelconstructed)), "AWGN", 0, 0, 1, 176 0.0002, &rt_ToWksSignalInfo, rt_ToWksBlockName); 177 178 if (rtDWork.To_Workspace1_PWORK.LoggedData == NULL) return; 179 } 180 181 MdlInitialize(); 182 } 183 184 /* Outputs for root system: '<Root>' */ 185 void MdlOutputs(int_T tid) 186 { 187 /* local block i/o variables */ 188 creal_T rtb_Join; 189 real_T rtb_Reshape_a; 190 real_T rtb_Complex_to_Real_Imag_o1; 191 real_T rtb_Complex_to_Real_Imag_o2; 192 real_T rtb_Reshape_b; 193 real_T rtb_temp15; 194 195 /* tid is required for a uniform function interface. This system 196 * is single rate, and in this case, tid is not accessed. */ 197 UNUSED_PARAMETER(tid); 198 199 /* RandomNumber: '<S2>/Random Number' */ 200 rtB.Random_Number_a = rtDWork.Random_Number_a_RWORK.NextOutput; 201 202 /* DiscreteStateSpace: '<S7>/Discrete State-Space' */ 203 { 204 rtb_temp15 = rtP.Discrete_State_Space_a_D*rtB.Random_Number_a; 205 } 206 207 /* ZeroOrderHold Block: '<S6>/zoh' 208 * 209 * Regarding '<S6>/zoh': 210 * Eliminated since input and output rates are identical 211 */ 212 213 /* Sum: '<S2>/Sum' incorporates: 214 * Constant: '<S6>/Constant' 215 */ 216 rtB.Sum_a = rtb_temp15 + rtP.Constant_a_Value; 217 218 /* DSP Blockset Buffer/Unbuffer (sdsprebuff2) - '<S2>/Buffer' */ 219 { 220 rtB.Buffer_a = rtB.Sum_a; 221 } 222 223 /* S-Function Block: <S2>/Reshape */ 224 rtb_Reshape_a = rtB.Buffer_a; 225 226 /* DSP Blockset Delay (sdspdly2) - '<S1>/Integer Delay' */ 227 228 { 229 int_T ti = rtDWork.Integer_Delay_BUFF_OFFSET; 230 231 memcpy(&rtb_temp15, ((byte_T *) &rtDWork.Integer_Delay_BUFF[0] + 232 (ti*sizeof(real_T))), sizeof(real_T)); 233 } 234 235 /* DiscretePulseGenerator: '<Root>/Pulse Generator' */ 236 rtB.Pulse_Generator = 237 (rtDWork.Pulse_Generator_IWORK.ClockTicksCounter < rtP.Pulse_Generator_Duty 238 && 239 rtDWork.Pulse_Generator_IWORK.ClockTicksCounter >= 0) ? 240 rtP.Pulse_Generator_Amp : 241 0.0; 242 if (rtDWork.Pulse_Generator_IWORK.ClockTicksCounter >= 243 rtP.Pulse_Generator_Period-1) { 244 rtDWork.Pulse_Generator_IWORK.ClockTicksCounter = 0; 245 } else { 246 (rtDWork.Pulse_Generator_IWORK.ClockTicksCounter)++; 247 } 248 249 /* DSP Blockset Filter Implementation (sdspfilter) - '<S5>/Direct-Form II Transpose Filter' */ 250 /* Filter algorithm: IIR Direct-Form II Transpose (double precision floating-point) */ 251 /* Complexities: input - real, num coeffs - real, den coeffs - real */ 252 /* Implementing filter algorithm */ 253 MWDSP_IIR_DF2T_DD(&rtB.Pulse_Generator, &rtB.Direct_Form_II_Tran, 254 &rtDWork.Direct_Form_II_Tran_FILT_STATES[0], 101, 1, 1, 255 &rtP.Direct_Form_II_Tran_RTP1COEFF[0], 100, 256 &rtP.Direct_Form_II_Tran_RTP2COEFF, 0, 1); 257 258 /* RealImagToComplex: '<S1>/Join' */ 259 rtb_Join.re = rtb_temp15; 260 rtb_Join.im = rtB.Direct_Form_II_Tran; 261 262 /* ComplexToRealImag: '<Root>/Complex to Real-Imag' */ 263 rtb_Complex_to_Real_Imag_o1 = rtb_Join.re; 264 rtb_Complex_to_Real_Imag_o2 = rtb_Join.im; 265 266 /* RandomNumber: '<S3>/Random Number' */ 267 rtB.Random_Number_b = rtDWork.Random_Number_b_RWORK.NextOutput; 268 269 /* DiscreteStateSpace: '<S11>/Discrete State-Space' */ 270 { 271 rtb_temp15 = rtP.Discrete_State_Space_b_D*rtB.Random_Number_b; 272 } 273 274 /* ZeroOrderHold Block: '<S10>/zoh' 275 * 276 * Regarding '<S10>/zoh': 277 * Eliminated since input and output rates are identical 278 */ 279 280 /* Sum: '<S3>/Sum' incorporates: 281 * Constant: '<S10>/Constant' 282 */ 283 rtB.Sum_b = rtb_temp15 + rtP.Constant_b_Value; 284 285 /* DSP Blockset Buffer/Unbuffer (sdsprebuff2) - '<S3>/Buffer' */ 286 { 287 rtB.Buffer_b = rtB.Sum_b; 288 } 289 290 /* S-Function Block: <S3>/Reshape */ 291 rtb_Reshape_b = rtB.Buffer_b; 292 293 /* Sum: '<Root>/Sum' incorporates: 294 * Product: '<Root>/Product1' 295 * Product: '<Root>/Product2' 296 */ 297 rtb_temp15 = (rtb_Reshape_a * rtb_Complex_to_Real_Imag_o1) 298 + (rtb_Complex_to_Real_Imag_o2 * rtb_Reshape_b); 299 300 /* ToWorkspace: '<Root>/To Workspace' */ 301 302 rt_UpdateStructLogVar(rtDWork.To_Workspace_PWORK.LoggedData, NULL, 303 &rtb_temp15); 304 305 /* ToWorkspace: '<Root>/To Workspace1' */ 306 307 rt_UpdateStructLogVar(rtDWork.To_Workspace1_PWORK.LoggedData, NULL, 308 &rtb_Reshape_b); 309 } 310 311 /* Update for root system: '<Root>' */ 312 void MdlUpdate(int_T tid) 313 { 314 315 /* tid is required for a uniform function interface. This system 316 * is single rate, and in this case, tid is not accessed. */ 317 UNUSED_PARAMETER(tid); 318 319 /* RandomNumber Block: <S2>/Random Number */ 320 rtDWork.Random_Number_a_RWORK.NextOutput = rt_NormalRand((uint_T 321 *)&rtDWork.Random_Number_a_IWORK.RandSeed)*rtP.Random_Number_a_StdDev+rtP.Random_Number_a_Mean; 322 323 /* DSP Blockset Delay (sdspdly2) - '<S1>/Integer Delay' */ 324 { 325 const int_T bytesPerElem = sizeof(real_T); 326 int_T bufferStart; 327 328 /* Scalar input */ 329 bufferStart = rtDWork.Integer_Delay_BUFF_OFFSET; 330 memcpy(((byte_T *) &rtDWork.Integer_Delay_BUFF[0]) + 331 (bufferStart*bytesPerElem), &rtB.Pulse_Generator, bytesPerElem); 332 rtDWork.Integer_Delay_BUFF_OFFSET += 1; 333 while (rtDWork.Integer_Delay_BUFF_OFFSET >= rtP.Integer_Delay_Delays) 334 rtDWork.Integer_Delay_BUFF_OFFSET -= rtP.Integer_Delay_Delays; 335 } 336 337 /* RandomNumber Block: <S3>/Random Number */ 338 rtDWork.Random_Number_b_RWORK.NextOutput = rt_NormalRand((uint_T 339 *)&rtDWork.Random_Number_b_IWORK.RandSeed)*rtP.Random_Number_b_StdDev+rtP.Random_Number_b_Mean; 340 } 341 342 /* Terminate for root system: '<Root>' */ 343 void MdlTerminate(void) 344 { 345 if(rtM_fadingchannelconstructed != NULL) { 346 } 347 } 348 349 /* Function to initialize sizes */ 350 void MdlInitializeSizes(void) 351 { 352 rtM_fadingchannelconstructed->Sizes.numContStates = (0); /* Number of continuous states */ 353 rtM_fadingchannelconstructed->Sizes.numY = (0); /* Number of model outputs */ 354 rtM_fadingchannelconstructed->Sizes.numU = (0); /* Number of model inputs */ 355 rtM_fadingchannelconstructed->Sizes.sysDirFeedThru = (0); /* The model is not direct feedthrough */ 356 rtM_fadingchannelconstructed->Sizes.numSampTimes = (1); /* Number of sample times */ 357 rtM_fadingchannelconstructed->Sizes.numBlocks = (22); /* Number of blocks */ 358 rtM_fadingchannelconstructed->Sizes.numBlockIO = (8); /* Number of block outputs */ 359 rtM_fadingchannelconstructed->Sizes.numBlockPrms = (124); /* Sum of parameter "widths" */ 360 } 361 362 /* Function to initialize sample times */ 363 void MdlInitializeSampleTimes(void) 364 { 365 /* task periods */ 366 rtM_fadingchannelconstructed->Timing.sampleTimes[0] = (0.0002); 367 368 /* task offsets */ 369 rtM_fadingchannelconstructed->Timing.offsetTimes[0] = (0.0); 370 } 371 372 /* Function to register the model */ 373 rtModel_fadingchannelconstructed *fadingchannelconstructed(void) 374 { 375 (void)memset((char *)rtM_fadingchannelconstructed, 0, 376 sizeof(rtModel_fadingchannelconstructed)); 377 378 { 379 /* Setup solver object */ 380 static RTWSolverInfo rt_SolverInfo; 381 rtM_fadingchannelconstructed->solverInfo = (&rt_SolverInfo); 382 383 rtsiSetSimTimeStepPtr(rtM_fadingchannelconstructed->solverInfo, 384 &rtM_fadingchannelconstructed->Timing.simTimeStep); 385 rtsiSetTPtr(rtM_fadingchannelconstructed->solverInfo, 386 &rtmGetTPtr(rtM_fadingchannelconstructed)); 387 rtsiSetStepSizePtr(rtM_fadingchannelconstructed->solverInfo, 388 &rtM_fadingchannelconstructed->Timing.stepSize); 389 rtsiSetdXPtr(rtM_fadingchannelconstructed->solverInfo, 390 &rtM_fadingchannelconstructed->ModelData.derivs); 391 rtsiSetContStatesPtr(rtM_fadingchannelconstructed->solverInfo, 392 &rtM_fadingchannelconstructed->ModelData.contStates); 393 rtsiSetNumContStatesPtr(rtM_fadingchannelconstructed->solverInfo, 394 &rtM_fadingchannelconstructed->Sizes.numContStates); 395 rtsiSetErrorStatusPtr(rtM_fadingchannelconstructed->solverInfo, 396 &rtmGetErrorStatus(rtM_fadingchannelconstructed)); 397 398 rtsiSetRTModelPtr(rtM_fadingchannelconstructed->solverInfo, 399 rtM_fadingchannelconstructed); 400 } 401 402 /* timing info */ 403 { 404 static time_T mdlPeriod[NSAMPLE_TIMES]; 405 static time_T mdlOffset[NSAMPLE_TIMES]; 406 static time_T mdlTaskTimes[NSAMPLE_TIMES]; 407 static int_T mdlTsMap[NSAMPLE_TIMES]; 408 static int_T mdlSampleHits[NSAMPLE_TIMES]; 409 410 { 411 int_T i; 412 413 for(i = 0; i < NSAMPLE_TIMES; i++) { 414 mdlPeriod[i] = 0.0; 415 mdlOffset[i] = 0.0; 416 mdlTaskTimes[i] = 0.0; 417 } 418 } 419 (void)memset((char_T *)&mdlTsMap[0], 0, 1 * sizeof(int_T)); 420 (void)memset((char_T *)&mdlSampleHits[0], 0, 1 * sizeof(int_T)); 421 422 rtM_fadingchannelconstructed->Timing.sampleTimes = (&mdlPeriod[0]); 423 rtM_fadingchannelconstructed->Timing.offsetTimes = (&mdlOffset[0]); 424 rtM_fadingchannelconstructed->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]); 425 rtmSetTPtr(rtM_fadingchannelconstructed, &mdlTaskTimes[0]); 426 rtM_fadingchannelconstructed->Timing.sampleHits = (&mdlSampleHits[0]); 427 } 428 rtsiSetSolverMode(rtM_fadingchannelconstructed->solverInfo, 429 SOLVER_MODE_SINGLETASKING); 430 431 /* 432 * initialize model vectors and cache them in SimStruct 433 */ 434 435 /* block I/O */ 436 { 437 void *b = (void *) &rtB; 438 rtM_fadingchannelconstructed->ModelData.blockIO = (b); 439 440 { 441 int_T i; 442 443 b =&rtB.Random_Number_a; 444 for (i = 0; i < 8; i++) { 445 ((real_T*)b)[i] = 0.0; 446 } 447 } 448 } 449 450 /* parameters */ 451 rtM_fadingchannelconstructed->ModelData.defaultParam = ((real_T *) &rtP); 452 453 /* data type work */ 454 { 455 void *dwork = (void *) &rtDWork; 456 rtM_fadingchannelconstructed->Work.dwork = (dwork); 457 (void)memset((char_T *) dwork, 0, sizeof(D_Work)); 458 { 459 int_T i; 460 real_T *dwork_ptr = (real_T *) &rtDWork.Integer_Delay_BUFF[0]; 461 462 for (i = 0; i < 154; i++) { 463 dwork_ptr[i] = 0.0; 464 } 465 } 466 } 467 468 /* Model specific registration */ 469 470 rtM_fadingchannelconstructed->modelName = ("fadingchannelconstructed"); 471 rtM_fadingchannelconstructed->path = ("fadingchannelconstructed"); 472 473 rtmSetTStart(rtM_fadingchannelconstructed, 0.0); 474 rtM_fadingchannelconstructed->Timing.tFinal = (10.0); 475 rtM_fadingchannelconstructed->Timing.stepSize = (0.0002); 476 rtsiSetFixedStepSize(rtM_fadingchannelconstructed->solverInfo, 0.0002); 477 /* Setup for data logging */ 478 { 479 static RTWLogInfo rt_DataLoggingInfo; 480 481 rtM_fadingchannelconstructed->rtwLogInfo = (&rt_DataLoggingInfo); 482 483 rtliSetLogFormat(rtM_fadingchannelconstructed->rtwLogInfo, 0); 484 485 rtliSetLogMaxRows(rtM_fadingchannelconstructed->rtwLogInfo, 1000); 486 487 rtliSetLogDecimation(rtM_fadingchannelconstructed->rtwLogInfo, 1); 488 489 rtliSetLogVarNameModifier(rtM_fadingchannelconstructed->rtwLogInfo, "none"); 490 491 rtliSetLogT(rtM_fadingchannelconstructed->rtwLogInfo, "tout"); 492 493 rtliSetLogX(rtM_fadingchannelconstructed->rtwLogInfo, ""); 494 495 rtliSetLogXFinal(rtM_fadingchannelconstructed->rtwLogInfo, ""); 496 497 rtliSetLogXSignalInfo(rtM_fadingchannelconstructed->rtwLogInfo, NULL); 498 499 rtliSetLogXSignalPtrs(rtM_fadingchannelconstructed->rtwLogInfo, NULL); 500 501 rtliSetLogY(rtM_fadingchannelconstructed->rtwLogInfo, ""); 502 503 rtliSetLogYSignalInfo(rtM_fadingchannelconstructed->rtwLogInfo, NULL); 504 505 rtliSetLogYSignalPtrs(rtM_fadingchannelconstructed->rtwLogInfo, NULL); 506 } 507 508 rtM_fadingchannelconstructed->Sizes.checksums[0] = (4095649789U); 509 rtM_fadingchannelconstructed->Sizes.checksums[1] = (2440085475U); 510 rtM_fadingchannelconstructed->Sizes.checksums[2] = (3216992539U); 511 rtM_fadingchannelconstructed->Sizes.checksums[3] = (240693362U); 512 513 return rtM_fadingchannelconstructed; 514 } 515 |