1423 lines
51 KiB
C++
1423 lines
51 KiB
C++
/*
|
|
* control_Velocidad.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 "control_Velocidad".
|
|
*
|
|
* Model version : 1.10
|
|
* Simulink Coder version : 24.2 (R2024b) 21-Jun-2024
|
|
* C++ source code generated on : Mon Jun 9 17:59:10 2025
|
|
*
|
|
* Target selection: speedgoat.tlc
|
|
* Note: GRT includes extra infrastructure and instrumentation for prototyping
|
|
* Embedded hardware selection: Intel->x86-64 (Linux 64)
|
|
* Code generation objectives: Unspecified
|
|
* Validation result: Not run
|
|
*/
|
|
|
|
#include "control_Velocidad.h"
|
|
#include "control_Velocidad_cal.h"
|
|
#include "rte_control_Velocidad_parameters.h"
|
|
#include <cmath>
|
|
#include "control_Velocidad_private.h"
|
|
#include "rtwtypes.h"
|
|
#include "zero_crossing_types.h"
|
|
#include <cstring>
|
|
|
|
extern "C"
|
|
{
|
|
|
|
#include "rt_nonfinite.h"
|
|
|
|
}
|
|
|
|
#include <cfloat>
|
|
|
|
/* Block signals (default storage) */
|
|
B_control_Velocidad_T control_Velocidad_B;
|
|
|
|
/* Block states (default storage) */
|
|
DW_control_Velocidad_T control_Velocidad_DW;
|
|
|
|
/* Previous zero-crossings (trigger) states */
|
|
PrevZCX_control_Velocidad_T control_Velocidad_PrevZCX;
|
|
|
|
/* Real-time model */
|
|
RT_MODEL_control_Velocidad_T control_Velocidad_M_ = RT_MODEL_control_Velocidad_T
|
|
();
|
|
RT_MODEL_control_Velocidad_T *const control_Velocidad_M = &control_Velocidad_M_;
|
|
real_T look1_pbinlxpw(real_T u0, const real_T bp0[], const real_T table[],
|
|
uint32_T prevIndex[], uint32_T maxIndex)
|
|
{
|
|
real_T frac;
|
|
real_T yL_0d0;
|
|
uint32_T bpIdx;
|
|
|
|
/* Column-major Lookup 1-D
|
|
Search method: 'binary'
|
|
Use previous index: 'on'
|
|
Interpolation method: 'Linear point-slope'
|
|
Extrapolation method: 'Linear'
|
|
Use last breakpoint for index at or above upper limit: 'off'
|
|
Remove protection against out-of-range input in generated code: 'off'
|
|
*/
|
|
/* Prelookup - Index and Fraction
|
|
Index Search method: 'binary'
|
|
Extrapolation method: 'Linear'
|
|
Use previous index: 'on'
|
|
Use last breakpoint for index at or above upper limit: 'off'
|
|
Remove protection against out-of-range input in generated code: 'off'
|
|
*/
|
|
if (u0 <= bp0[0U]) {
|
|
bpIdx = 0U;
|
|
frac = (u0 - bp0[0U]) / (bp0[1U] - bp0[0U]);
|
|
} else if (u0 < bp0[maxIndex]) {
|
|
uint32_T found;
|
|
uint32_T iLeft;
|
|
uint32_T iRght;
|
|
|
|
/* Binary Search using Previous Index */
|
|
bpIdx = prevIndex[0U];
|
|
iLeft = 0U;
|
|
iRght = maxIndex;
|
|
found = 0U;
|
|
while (found == 0U) {
|
|
if (u0 < bp0[bpIdx]) {
|
|
iRght = bpIdx - 1U;
|
|
bpIdx = ((bpIdx + iLeft) - 1U) >> 1U;
|
|
} else if (u0 < bp0[bpIdx + 1U]) {
|
|
found = 1U;
|
|
} else {
|
|
iLeft = bpIdx + 1U;
|
|
bpIdx = ((bpIdx + iRght) + 1U) >> 1U;
|
|
}
|
|
}
|
|
|
|
frac = (u0 - bp0[bpIdx]) / (bp0[bpIdx + 1U] - bp0[bpIdx]);
|
|
} else {
|
|
bpIdx = maxIndex - 1U;
|
|
frac = (u0 - bp0[maxIndex - 1U]) / (bp0[maxIndex] - bp0[maxIndex - 1U]);
|
|
}
|
|
|
|
prevIndex[0U] = bpIdx;
|
|
|
|
/* Column-major Interpolation 1-D
|
|
Interpolation method: 'Linear point-slope'
|
|
Use last breakpoint for index at or above upper limit: 'off'
|
|
Overflow mode: 'portable wrapping'
|
|
*/
|
|
yL_0d0 = table[bpIdx];
|
|
return (table[bpIdx + 1U] - yL_0d0) * frac + yL_0d0;
|
|
}
|
|
|
|
real_T rt_remd_snf(real_T u0, real_T u1)
|
|
{
|
|
real_T y;
|
|
if (rtIsNaN(u0) || rtIsNaN(u1) || rtIsInf(u0)) {
|
|
y = (rtNaN);
|
|
} else if (rtIsInf(u1)) {
|
|
y = u0;
|
|
} else {
|
|
if (u1 < 0.0) {
|
|
y = std::ceil(u1);
|
|
} else {
|
|
y = std::floor(u1);
|
|
}
|
|
|
|
if ((u1 != 0.0) && (u1 != y)) {
|
|
real_T q;
|
|
q = std::abs(u0 / u1);
|
|
if (!(std::abs(q - std::floor(q + 0.5)) > DBL_EPSILON * q)) {
|
|
y = 0.0 * u0;
|
|
} else {
|
|
y = std::fmod(u0, u1);
|
|
}
|
|
} else {
|
|
y = std::fmod(u0, u1);
|
|
}
|
|
}
|
|
|
|
return y;
|
|
}
|
|
|
|
/* Model step function for TID0 */
|
|
void control_Velocidad_step0(void) /* Sample time: [0.0s, 0.0s] */
|
|
{
|
|
real_T u0;
|
|
ZCSigState SampleandHold1_Trig_ZCE_tmp;
|
|
boolean_T zcEvent;
|
|
|
|
/* Reset subsysRan breadcrumbs */
|
|
srClearBC(control_Velocidad_DW.TriggeredSubsystem_SubsysRanBC);
|
|
|
|
/* Reset subsysRan breadcrumbs */
|
|
srClearBC(control_Velocidad_DW.NEGATIVEEdge_SubsysRanBC);
|
|
|
|
/* Reset subsysRan breadcrumbs */
|
|
srClearBC(control_Velocidad_DW.POSITIVEEdge_SubsysRanBC);
|
|
|
|
/* Reset subsysRan breadcrumbs */
|
|
srClearBC(control_Velocidad_DW.SampleandHold1_SubsysRanBC);
|
|
|
|
/* Gain: '<Root>/CTE_amplitud' incorporates:
|
|
* Constant: '<Root>/Constant1'
|
|
*/
|
|
control_Velocidad_B.CTE_amplitud = *get_cte_amplitud() *
|
|
control_Velocidad_cal->Constant1_Value;
|
|
|
|
/* DiscreteIntegrator: '<S1>/Discrete-Time Integrator' */
|
|
control_Velocidad_B.DiscreteTimeIntegrator =
|
|
control_Velocidad_DW.DiscreteTimeIntegrator_DSTATE;
|
|
|
|
/* Trigonometry: '<S1>/Trigonometric Function' */
|
|
control_Velocidad_B.TrigonometricFunction = std::sin
|
|
(control_Velocidad_B.DiscreteTimeIntegrator);
|
|
|
|
/* Sum: '<S1>/Sum' incorporates:
|
|
* Constant: '<S1>/Constant1'
|
|
*/
|
|
control_Velocidad_B.Sum = control_Velocidad_B.DiscreteTimeIntegrator +
|
|
control_Velocidad_cal->Constant1_Value_l;
|
|
|
|
/* Trigonometry: '<S1>/Trigonometric Function1' */
|
|
control_Velocidad_B.TrigonometricFunction1 = std::sin(control_Velocidad_B.Sum);
|
|
|
|
/* Sum: '<S1>/Sum1' incorporates:
|
|
* Constant: '<S1>/Constant2'
|
|
*/
|
|
control_Velocidad_B.Sum1 = control_Velocidad_B.DiscreteTimeIntegrator +
|
|
control_Velocidad_cal->Constant2_Value;
|
|
|
|
/* Trigonometry: '<S1>/Trigonometric Function2' */
|
|
control_Velocidad_B.TrigonometricFunction2 = std::sin(control_Velocidad_B.Sum1);
|
|
|
|
/* Product: '<Root>/Product' */
|
|
control_Velocidad_B.Product[0] = control_Velocidad_B.CTE_amplitud *
|
|
control_Velocidad_B.TrigonometricFunction;
|
|
control_Velocidad_B.Product[1] = control_Velocidad_B.CTE_amplitud *
|
|
control_Velocidad_B.TrigonometricFunction1;
|
|
control_Velocidad_B.Product[2] = control_Velocidad_B.CTE_amplitud *
|
|
control_Velocidad_B.TrigonometricFunction2;
|
|
|
|
/* Saturate: '<Root>/Saturation' */
|
|
u0 = control_Velocidad_B.Product[0];
|
|
if (u0 > control_Velocidad_cal->Saturation_UpperSat) {
|
|
u0 = control_Velocidad_cal->Saturation_UpperSat;
|
|
} else if (u0 < control_Velocidad_cal->Saturation_LowerSat) {
|
|
u0 = control_Velocidad_cal->Saturation_LowerSat;
|
|
}
|
|
|
|
/* Saturate: '<Root>/Saturation' */
|
|
control_Velocidad_B.Saturation[0] = u0;
|
|
|
|
/* Saturate: '<Root>/Saturation' */
|
|
u0 = control_Velocidad_B.Product[1];
|
|
if (u0 > control_Velocidad_cal->Saturation_UpperSat) {
|
|
u0 = control_Velocidad_cal->Saturation_UpperSat;
|
|
} else if (u0 < control_Velocidad_cal->Saturation_LowerSat) {
|
|
u0 = control_Velocidad_cal->Saturation_LowerSat;
|
|
}
|
|
|
|
/* Saturate: '<Root>/Saturation' */
|
|
control_Velocidad_B.Saturation[1] = u0;
|
|
|
|
/* Saturate: '<Root>/Saturation' */
|
|
u0 = control_Velocidad_B.Product[2];
|
|
if (u0 > control_Velocidad_cal->Saturation_UpperSat) {
|
|
u0 = control_Velocidad_cal->Saturation_UpperSat;
|
|
} else if (u0 < control_Velocidad_cal->Saturation_LowerSat) {
|
|
u0 = control_Velocidad_cal->Saturation_LowerSat;
|
|
}
|
|
|
|
/* Saturate: '<Root>/Saturation' */
|
|
control_Velocidad_B.Saturation[2] = u0;
|
|
|
|
/* DigitalClock: '<S13>/Digital Clock' */
|
|
control_Velocidad_B.DigitalClock = control_Velocidad_M->Timing.t[1];
|
|
|
|
/* Sum: '<S13>/Add1' incorporates:
|
|
* Constant: '<S13>/Constant3'
|
|
*/
|
|
control_Velocidad_B.Add1 = control_Velocidad_B.DigitalClock +
|
|
control_Velocidad_cal->Constant3_Value;
|
|
|
|
/* Math: '<S13>/Math Function' incorporates:
|
|
* Constant: '<S13>/Constant1'
|
|
*/
|
|
control_Velocidad_B.MathFunction = rt_remd_snf(control_Velocidad_B.Add1,
|
|
control_Velocidad_cal->Constant1_Value_l0);
|
|
|
|
/* Gain: '<S13>/1\ib1' */
|
|
control_Velocidad_B.uib1 = control_Velocidad_cal->uib1_Gain *
|
|
control_Velocidad_B.MathFunction;
|
|
|
|
/* Lookup_n-D: '<S13>/1-D Lookup Table' incorporates:
|
|
* Gain: '<S13>/1\ib1'
|
|
*/
|
|
control_Velocidad_B.uDLookupTable = look1_pbinlxpw(control_Velocidad_B.uib1,
|
|
control_Velocidad_cal->uDLookupTable_bp01Data,
|
|
control_Velocidad_cal->uDLookupTable_tableData,
|
|
&control_Velocidad_DW.m_bpIndex, 2U);
|
|
|
|
/* Sum: '<S13>/Add3' incorporates:
|
|
* Constant: '<S13>/Constant2'
|
|
*/
|
|
control_Velocidad_B.Add3 = control_Velocidad_B.uDLookupTable -
|
|
control_Velocidad_cal->Constant2_Value_i;
|
|
|
|
/* Sum: '<S4>/Add3' incorporates:
|
|
* Constant: '<S2>/Constant10'
|
|
*/
|
|
control_Velocidad_B.Add3_b = control_Velocidad_cal->PWMGenerator2Level_MinMax
|
|
[1] - control_Velocidad_cal->PWMGenerator2Level_MinMax[0];
|
|
|
|
/* Gain: '<S4>/Gain1' */
|
|
control_Velocidad_B.Gain1 = control_Velocidad_cal->Gain1_Gain *
|
|
control_Velocidad_B.Add3_b;
|
|
|
|
/* Product: '<S4>/MUL1' */
|
|
control_Velocidad_B.MUL1 = control_Velocidad_B.Add3 *
|
|
control_Velocidad_B.Gain1;
|
|
|
|
/* Sum: '<S4>/Add4' incorporates:
|
|
* Constant: '<S2>/Constant10'
|
|
*/
|
|
control_Velocidad_B.Add4 = (control_Velocidad_cal->PWMGenerator2Level_MinMax[0]
|
|
+ control_Velocidad_B.MUL1) + control_Velocidad_B.Gain1;
|
|
|
|
/* RelationalOperator: '<S8>/Relational Operator2' */
|
|
zcEvent = (control_Velocidad_B.Saturation[0] >= control_Velocidad_B.Add4);
|
|
control_Velocidad_B.RelationalOperator2[0] = zcEvent;
|
|
|
|
/* Logic: '<S2>/Logical Operator4' */
|
|
control_Velocidad_B.LogicalOperator4[0] = !zcEvent;
|
|
|
|
/* RelationalOperator: '<S8>/Relational Operator2' */
|
|
zcEvent = (control_Velocidad_B.Saturation[1] >= control_Velocidad_B.Add4);
|
|
control_Velocidad_B.RelationalOperator2[1] = zcEvent;
|
|
|
|
/* Logic: '<S2>/Logical Operator4' */
|
|
control_Velocidad_B.LogicalOperator4[1] = !zcEvent;
|
|
|
|
/* RelationalOperator: '<S8>/Relational Operator2' */
|
|
zcEvent = (control_Velocidad_B.Saturation[2] >= control_Velocidad_B.Add4);
|
|
control_Velocidad_B.RelationalOperator2[2] = zcEvent;
|
|
|
|
/* Logic: '<S2>/Logical Operator4' */
|
|
control_Velocidad_B.LogicalOperator4[2] = !zcEvent;
|
|
|
|
/* DataTypeConversion: '<S2>/Data Type Conversion' */
|
|
control_Velocidad_B.DataTypeConversion[0] =
|
|
control_Velocidad_B.RelationalOperator2[0];
|
|
control_Velocidad_B.DataTypeConversion[1] =
|
|
control_Velocidad_B.LogicalOperator4[0];
|
|
control_Velocidad_B.DataTypeConversion[2] =
|
|
control_Velocidad_B.RelationalOperator2[1];
|
|
control_Velocidad_B.DataTypeConversion[3] =
|
|
control_Velocidad_B.LogicalOperator4[1];
|
|
control_Velocidad_B.DataTypeConversion[4] =
|
|
control_Velocidad_B.RelationalOperator2[2];
|
|
control_Velocidad_B.DataTypeConversion[5] =
|
|
control_Velocidad_B.LogicalOperator4[2];
|
|
|
|
/* S-Function (sg_fpga_do_sf_a2): '<Root>/Digital output' */
|
|
|
|
/* Level2 S-Function Block: '<Root>/Digital output' (sg_fpga_do_sf_a2) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[0];
|
|
sfcnOutputs(rts,0);
|
|
}
|
|
|
|
/* Gain: '<S1>/Gain' incorporates:
|
|
* Constant: '<Root>/Constant1'
|
|
*/
|
|
control_Velocidad_B.Gain = control_Velocidad_cal->Gain_Gain *
|
|
control_Velocidad_cal->Constant1_Value;
|
|
|
|
/* Delay: '<S3>/Delay1' */
|
|
control_Velocidad_B.Delay1 = control_Velocidad_DW.Delay1_DSTATE;
|
|
|
|
/* S-Function (sg_fpga_di_sf_a2): '<Root>/Digital input' */
|
|
|
|
/* Level2 S-Function Block: '<Root>/Digital input' (sg_fpga_di_sf_a2) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[1];
|
|
sfcnOutputs(rts,0);
|
|
}
|
|
|
|
/* DataTypeConversion: '<S3>/Cast To Boolean' */
|
|
control_Velocidad_B.CastToBoolean = (control_Velocidad_B.Digitalinput_o1 !=
|
|
0.0);
|
|
|
|
/* DataTypeConversion: '<S17>/Data Type Conversion2' */
|
|
control_Velocidad_B.DataTypeConversion2 = control_Velocidad_B.CastToBoolean;
|
|
|
|
/* Memory: '<S17>/Memory' */
|
|
control_Velocidad_B.Memory = control_Velocidad_DW.Memory_PreviousInput;
|
|
|
|
/* MultiPortSwitch: '<S17>/Multiport Switch' incorporates:
|
|
* Constant: '<S17>/Constant1'
|
|
*/
|
|
switch (static_cast<int32_T>(control_Velocidad_cal->EdgeDetector_model)) {
|
|
case 1:
|
|
/* MultiPortSwitch: '<S17>/Multiport Switch' incorporates:
|
|
* Constant: '<S17>/pos. edge'
|
|
*/
|
|
control_Velocidad_B.MultiportSwitch[0] =
|
|
control_Velocidad_cal->posedge_Value[0];
|
|
control_Velocidad_B.MultiportSwitch[1] =
|
|
control_Velocidad_cal->posedge_Value[1];
|
|
break;
|
|
|
|
case 2:
|
|
/* MultiPortSwitch: '<S17>/Multiport Switch' incorporates:
|
|
* Constant: '<S17>/neg. edge'
|
|
*/
|
|
control_Velocidad_B.MultiportSwitch[0] =
|
|
control_Velocidad_cal->negedge_Value[0];
|
|
control_Velocidad_B.MultiportSwitch[1] =
|
|
control_Velocidad_cal->negedge_Value[1];
|
|
break;
|
|
|
|
default:
|
|
/* MultiPortSwitch: '<S17>/Multiport Switch' incorporates:
|
|
* Constant: '<S17>/either edge'
|
|
*/
|
|
control_Velocidad_B.MultiportSwitch[0] =
|
|
control_Velocidad_cal->eitheredge_Value[0];
|
|
control_Velocidad_B.MultiportSwitch[1] =
|
|
control_Velocidad_cal->eitheredge_Value[1];
|
|
break;
|
|
}
|
|
|
|
/* End of MultiPortSwitch: '<S17>/Multiport Switch' */
|
|
|
|
/* Outputs for Enabled SubSystem: '<S17>/POSITIVE Edge' incorporates:
|
|
* EnablePort: '<S20>/Enable'
|
|
*/
|
|
if (control_Velocidad_B.MultiportSwitch[0] > 0.0) {
|
|
if (!control_Velocidad_DW.POSITIVEEdge_MODE) {
|
|
control_Velocidad_DW.POSITIVEEdge_MODE = true;
|
|
}
|
|
|
|
/* RelationalOperator: '<S20>/Relational Operator1' */
|
|
control_Velocidad_B.RelationalOperator1 = (static_cast<int32_T>
|
|
(control_Velocidad_B.Memory) < static_cast<int32_T>
|
|
(control_Velocidad_B.DataTypeConversion2));
|
|
srUpdateBC(control_Velocidad_DW.POSITIVEEdge_SubsysRanBC);
|
|
} else if (control_Velocidad_DW.POSITIVEEdge_MODE) {
|
|
control_Velocidad_DW.POSITIVEEdge_MODE = false;
|
|
}
|
|
|
|
/* End of Outputs for SubSystem: '<S17>/POSITIVE Edge' */
|
|
|
|
/* Outputs for Enabled SubSystem: '<S17>/NEGATIVE Edge' incorporates:
|
|
* EnablePort: '<S19>/Enable'
|
|
*/
|
|
if (control_Velocidad_B.MultiportSwitch[1] > 0.0) {
|
|
if (!control_Velocidad_DW.NEGATIVEEdge_MODE) {
|
|
control_Velocidad_DW.NEGATIVEEdge_MODE = true;
|
|
}
|
|
|
|
/* RelationalOperator: '<S19>/Relational Operator1' */
|
|
control_Velocidad_B.RelationalOperator1_e = (static_cast<int32_T>
|
|
(control_Velocidad_B.Memory) > static_cast<int32_T>
|
|
(control_Velocidad_B.DataTypeConversion2));
|
|
srUpdateBC(control_Velocidad_DW.NEGATIVEEdge_SubsysRanBC);
|
|
} else if (control_Velocidad_DW.NEGATIVEEdge_MODE) {
|
|
control_Velocidad_DW.NEGATIVEEdge_MODE = false;
|
|
}
|
|
|
|
/* End of Outputs for SubSystem: '<S17>/NEGATIVE Edge' */
|
|
|
|
/* Logic: '<S17>/Logical Operator1' */
|
|
control_Velocidad_B.LogicalOperator1 =
|
|
(control_Velocidad_B.RelationalOperator1 ||
|
|
control_Velocidad_B.RelationalOperator1_e);
|
|
|
|
/* Gain: '<S3>/CTE Encoder' */
|
|
control_Velocidad_B.CTEEncoder = control_Velocidad_B.LogicalOperator1 ?
|
|
*get_cte_encoder() : 0UL;
|
|
|
|
/* DataTypeConversion: '<S3>/Cast To Boolean1' */
|
|
control_Velocidad_B.CastToBoolean1 = (control_Velocidad_B.Digitalinput_o2 !=
|
|
0.0);
|
|
|
|
/* Clock: '<S3>/Clock' incorporates:
|
|
* Clock: '<S18>/Clock'
|
|
*/
|
|
u0 = control_Velocidad_M->Timing.t[0];
|
|
|
|
/* Clock: '<S3>/Clock' */
|
|
control_Velocidad_B.Clock = u0;
|
|
|
|
/* Outputs for Triggered SubSystem: '<S3>/Sample and Hold1' incorporates:
|
|
* TriggerPort: '<S16>/Trigger'
|
|
*/
|
|
zcEvent = (control_Velocidad_B.LogicalOperator1 &&
|
|
(control_Velocidad_PrevZCX.SampleandHold1_Trig_ZCE != POS_ZCSIG));
|
|
if (zcEvent) {
|
|
/* SignalConversion generated from: '<S16>/In' */
|
|
control_Velocidad_B.In = control_Velocidad_B.Clock;
|
|
control_Velocidad_DW.SampleandHold1_SubsysRanBC = 4;
|
|
}
|
|
|
|
SampleandHold1_Trig_ZCE_tmp = control_Velocidad_B.LogicalOperator1;
|
|
control_Velocidad_PrevZCX.SampleandHold1_Trig_ZCE =
|
|
SampleandHold1_Trig_ZCE_tmp;
|
|
|
|
/* End of Outputs for SubSystem: '<S3>/Sample and Hold1' */
|
|
|
|
/* UnitDelay: '<S14>/UD' */
|
|
control_Velocidad_B.Uk1 = control_Velocidad_DW.UD_DSTATE;
|
|
|
|
/* Sum: '<S14>/Diff' */
|
|
control_Velocidad_B.Diff = control_Velocidad_B.In - control_Velocidad_B.Uk1;
|
|
|
|
/* Delay: '<S3>/Delay' */
|
|
control_Velocidad_B.Delay = control_Velocidad_DW.Delay_DSTATE;
|
|
|
|
/* Switch: '<S3>/Switch' */
|
|
if (control_Velocidad_B.Diff > *get_limite_direccion()) {
|
|
/* Logic: '<S3>/Logical Operator' */
|
|
control_Velocidad_B.LogicalOperator = (control_Velocidad_B.LogicalOperator1 &&
|
|
control_Velocidad_B.CastToBoolean1);
|
|
|
|
/* Switch: '<S3>/Switch1' */
|
|
if (control_Velocidad_B.LogicalOperator) {
|
|
/* Switch: '<S3>/Switch1' incorporates:
|
|
* Constant: '<S3>/Constant1'
|
|
*/
|
|
control_Velocidad_B.Switch1 = control_Velocidad_cal->Constant1_Value_n;
|
|
} else {
|
|
/* Switch: '<S3>/Switch1' incorporates:
|
|
* Constant: '<S3>/Constant2'
|
|
*/
|
|
control_Velocidad_B.Switch1 = control_Velocidad_cal->Constant2_Value_b;
|
|
}
|
|
|
|
/* End of Switch: '<S3>/Switch1' */
|
|
|
|
/* Switch: '<S3>/Switch' */
|
|
control_Velocidad_B.Switch = control_Velocidad_B.Switch1;
|
|
} else {
|
|
/* Switch: '<S3>/Switch' */
|
|
control_Velocidad_B.Switch = control_Velocidad_B.Delay;
|
|
}
|
|
|
|
/* End of Switch: '<S3>/Switch' */
|
|
|
|
/* Product: '<S3>/Product' incorporates:
|
|
* Gain: '<S3>/CTE Encoder'
|
|
*/
|
|
control_Velocidad_B.Product_o = static_cast<real_T>
|
|
(control_Velocidad_B.CTEEncoder) * 8.4703294725430034E-22 *
|
|
control_Velocidad_B.Switch;
|
|
|
|
/* Sum: '<S3>/Add' */
|
|
control_Velocidad_B.Add = control_Velocidad_B.Delay1 +
|
|
control_Velocidad_B.Product_o;
|
|
|
|
/* Clock: '<S18>/Clock' */
|
|
control_Velocidad_B.Clock_e = u0;
|
|
|
|
/* Outputs for Triggered SubSystem: '<S18>/Triggered Subsystem' incorporates:
|
|
* TriggerPort: '<S21>/Trigger'
|
|
*/
|
|
zcEvent = (control_Velocidad_B.LogicalOperator1 &&
|
|
(control_Velocidad_PrevZCX.TriggeredSubsystem_Trig_ZCE != POS_ZCSIG));
|
|
if (zcEvent) {
|
|
/* SignalConversion generated from: '<S21>/In1' */
|
|
control_Velocidad_B.In1 = control_Velocidad_B.Clock_e;
|
|
control_Velocidad_DW.TriggeredSubsystem_SubsysRanBC = 4;
|
|
}
|
|
|
|
control_Velocidad_PrevZCX.TriggeredSubsystem_Trig_ZCE =
|
|
SampleandHold1_Trig_ZCE_tmp;
|
|
|
|
/* End of Outputs for SubSystem: '<S18>/Triggered Subsystem' */
|
|
|
|
/* Sum: '<S18>/Sum' incorporates:
|
|
* Constant: '<S18>/Constant'
|
|
*/
|
|
control_Velocidad_B.Sum_g = control_Velocidad_B.In1 +
|
|
control_Velocidad_cal->Constant_Value;
|
|
|
|
/* RelationalOperator: '<S18>/Relational Operator' */
|
|
control_Velocidad_B.RelationalOperator = (control_Velocidad_B.Sum_g >
|
|
control_Velocidad_B.Clock_e);
|
|
|
|
/* user code (Output function Trailer for TID0) */
|
|
{
|
|
}
|
|
|
|
/* Update for DiscreteIntegrator: '<S1>/Discrete-Time Integrator' */
|
|
control_Velocidad_DW.DiscreteTimeIntegrator_DSTATE +=
|
|
control_Velocidad_cal->DiscreteTimeIntegrator_gainval *
|
|
control_Velocidad_B.Gain;
|
|
|
|
/* Update for Delay: '<S3>/Delay1' */
|
|
control_Velocidad_DW.Delay1_DSTATE = control_Velocidad_B.Add;
|
|
|
|
/* Update for Memory: '<S17>/Memory' */
|
|
control_Velocidad_DW.Memory_PreviousInput =
|
|
control_Velocidad_B.DataTypeConversion2;
|
|
|
|
/* Update for UnitDelay: '<S14>/UD' */
|
|
control_Velocidad_DW.UD_DSTATE = control_Velocidad_B.In;
|
|
|
|
/* Update for Delay: '<S3>/Delay' */
|
|
control_Velocidad_DW.Delay_DSTATE = control_Velocidad_B.Switch;
|
|
|
|
/* Update absolute time */
|
|
/* 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 (!(++control_Velocidad_M->Timing.clockTick0)) {
|
|
++control_Velocidad_M->Timing.clockTickH0;
|
|
}
|
|
|
|
control_Velocidad_M->Timing.t[0] = control_Velocidad_M->Timing.clockTick0 *
|
|
control_Velocidad_M->Timing.stepSize0 +
|
|
control_Velocidad_M->Timing.clockTickH0 *
|
|
control_Velocidad_M->Timing.stepSize0 * 4294967296.0;
|
|
|
|
/* Update absolute time */
|
|
/* The "clockTick1" counts the number of times the code of this task has
|
|
* been executed. The absolute time is the multiplication of "clockTick1"
|
|
* and "Timing.stepSize1". 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.
|
|
*/
|
|
if (!(++control_Velocidad_M->Timing.clockTick1)) {
|
|
++control_Velocidad_M->Timing.clockTickH1;
|
|
}
|
|
|
|
control_Velocidad_M->Timing.t[1] = control_Velocidad_M->Timing.clockTick1 *
|
|
control_Velocidad_M->Timing.stepSize1 +
|
|
control_Velocidad_M->Timing.clockTickH1 *
|
|
control_Velocidad_M->Timing.stepSize1 * 4294967296.0;
|
|
}
|
|
|
|
/* Model step function for TID2 */
|
|
void control_Velocidad_step2(void) /* Sample time: [0.001s, 0.0s] */
|
|
{
|
|
/* S-Function (sg_fpga_IO397_ad): '<Root>/IO397 Analog Input' */
|
|
|
|
/* Level2 S-Function Block: '<Root>/IO397 Analog Input' (sg_fpga_IO397_ad) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[2];
|
|
sfcnOutputs(rts,2);
|
|
}
|
|
|
|
/* Gain: '<Root>/Gain' */
|
|
control_Velocidad_B.Gain_n = control_Velocidad_cal->Gain_Gain_j *
|
|
control_Velocidad_B.IO397AnalogInput_o1;
|
|
|
|
/* Gain: '<Root>/Gain1' */
|
|
control_Velocidad_B.Gain1_j = control_Velocidad_cal->Gain1_Gain_j *
|
|
control_Velocidad_B.IO397AnalogInput_o2;
|
|
|
|
/* Gain: '<Root>/Gain2' */
|
|
control_Velocidad_B.Gain2 = control_Velocidad_cal->Gain2_Gain *
|
|
control_Velocidad_B.IO397AnalogInput_o3;
|
|
|
|
/* Update absolute time */
|
|
/* The "clockTick2" counts the number of times the code of this task has
|
|
* been executed. The absolute time is the multiplication of "clockTick2"
|
|
* and "Timing.stepSize2". Size of "clockTick2" 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.clockTick2 and the high bits
|
|
* Timing.clockTickH2. When the low bit overflows to 0, the high bits increment.
|
|
*/
|
|
if (!(++control_Velocidad_M->Timing.clockTick2)) {
|
|
++control_Velocidad_M->Timing.clockTickH2;
|
|
}
|
|
|
|
control_Velocidad_M->Timing.t[2] = control_Velocidad_M->Timing.clockTick2 *
|
|
control_Velocidad_M->Timing.stepSize2 +
|
|
control_Velocidad_M->Timing.clockTickH2 *
|
|
control_Velocidad_M->Timing.stepSize2 * 4294967296.0;
|
|
}
|
|
|
|
/* Model initialize function */
|
|
void control_Velocidad_initialize(void)
|
|
{
|
|
/* Registration code */
|
|
|
|
/* initialize non-finites */
|
|
rt_InitInfAndNaN(sizeof(real_T));
|
|
|
|
/* Set task counter limit used by the static main program */
|
|
(control_Velocidad_M)->Timing.TaskCounters.cLimit[0] = 1;
|
|
(control_Velocidad_M)->Timing.TaskCounters.cLimit[1] = 1;
|
|
(control_Velocidad_M)->Timing.TaskCounters.cLimit[2] = 26;
|
|
|
|
{
|
|
/* Setup solver object */
|
|
rtsiSetSimTimeStepPtr(&control_Velocidad_M->solverInfo,
|
|
&control_Velocidad_M->Timing.simTimeStep);
|
|
rtsiSetTPtr(&control_Velocidad_M->solverInfo, &rtmGetTPtr
|
|
(control_Velocidad_M));
|
|
rtsiSetStepSizePtr(&control_Velocidad_M->solverInfo,
|
|
&control_Velocidad_M->Timing.stepSize0);
|
|
rtsiSetErrorStatusPtr(&control_Velocidad_M->solverInfo, (&rtmGetErrorStatus
|
|
(control_Velocidad_M)));
|
|
rtsiSetRTModelPtr(&control_Velocidad_M->solverInfo, control_Velocidad_M);
|
|
}
|
|
|
|
rtsiSetSimTimeStep(&control_Velocidad_M->solverInfo, MAJOR_TIME_STEP);
|
|
rtsiSetIsMinorTimeStepWithModeChange(&control_Velocidad_M->solverInfo, false);
|
|
rtsiSetIsContModeFrozen(&control_Velocidad_M->solverInfo, false);
|
|
rtsiSetSolverName(&control_Velocidad_M->solverInfo,"FixedStepDiscrete");
|
|
control_Velocidad_M->solverInfoPtr = (&control_Velocidad_M->solverInfo);
|
|
|
|
/* Initialize timing info */
|
|
{
|
|
int_T *mdlTsMap = control_Velocidad_M->Timing.sampleTimeTaskIDArray;
|
|
mdlTsMap[0] = 0;
|
|
mdlTsMap[1] = 1;
|
|
mdlTsMap[2] = 2;
|
|
control_Velocidad_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
|
|
control_Velocidad_M->Timing.sampleTimes =
|
|
(&control_Velocidad_M->Timing.sampleTimesArray[0]);
|
|
control_Velocidad_M->Timing.offsetTimes =
|
|
(&control_Velocidad_M->Timing.offsetTimesArray[0]);
|
|
|
|
/* task periods */
|
|
control_Velocidad_M->Timing.sampleTimes[0] = (0.0);
|
|
control_Velocidad_M->Timing.sampleTimes[1] = (3.8461538461538463E-5);
|
|
control_Velocidad_M->Timing.sampleTimes[2] = (0.001);
|
|
|
|
/* task offsets */
|
|
control_Velocidad_M->Timing.offsetTimes[0] = (0.0);
|
|
control_Velocidad_M->Timing.offsetTimes[1] = (0.0);
|
|
control_Velocidad_M->Timing.offsetTimes[2] = (0.0);
|
|
}
|
|
|
|
rtmSetTPtr(control_Velocidad_M, &control_Velocidad_M->Timing.tArray[0]);
|
|
|
|
{
|
|
int_T *mdlSampleHits = control_Velocidad_M->Timing.sampleHitArray;
|
|
int_T *mdlPerTaskSampleHits =
|
|
control_Velocidad_M->Timing.perTaskSampleHitsArray;
|
|
control_Velocidad_M->Timing.perTaskSampleHits = (&mdlPerTaskSampleHits[0]);
|
|
mdlSampleHits[0] = 1;
|
|
control_Velocidad_M->Timing.sampleHits = (&mdlSampleHits[0]);
|
|
}
|
|
|
|
rtmSetTFinal(control_Velocidad_M, -1);
|
|
control_Velocidad_M->Timing.stepSize0 = 3.8461538461538463E-5;
|
|
control_Velocidad_M->Timing.stepSize1 = 3.8461538461538463E-5;
|
|
control_Velocidad_M->Timing.stepSize2 = 0.001;
|
|
control_Velocidad_M->solverInfoPtr = (&control_Velocidad_M->solverInfo);
|
|
control_Velocidad_M->Timing.stepSize = (3.8461538461538463E-5);
|
|
rtsiSetFixedStepSize(&control_Velocidad_M->solverInfo, 3.8461538461538463E-5);
|
|
rtsiSetSolverMode(&control_Velocidad_M->solverInfo, SOLVER_MODE_MULTITASKING);
|
|
|
|
/* block I/O */
|
|
(void) std::memset((static_cast<void *>(&control_Velocidad_B)), 0,
|
|
sizeof(B_control_Velocidad_T));
|
|
|
|
/* states (dwork) */
|
|
(void) std::memset(static_cast<void *>(&control_Velocidad_DW), 0,
|
|
sizeof(DW_control_Velocidad_T));
|
|
|
|
/* child S-Function registration */
|
|
{
|
|
RTWSfcnInfo *sfcnInfo = &control_Velocidad_M->NonInlinedSFcns.sfcnInfo;
|
|
control_Velocidad_M->sfcnInfo = (sfcnInfo);
|
|
rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(control_Velocidad_M)));
|
|
control_Velocidad_M->Sizes.numSampTimes = (3);
|
|
rtssSetNumRootSampTimesPtr(sfcnInfo,
|
|
&control_Velocidad_M->Sizes.numSampTimes);
|
|
control_Velocidad_M->NonInlinedSFcns.taskTimePtrs[0] = (&rtmGetTPtr
|
|
(control_Velocidad_M)[0]);
|
|
control_Velocidad_M->NonInlinedSFcns.taskTimePtrs[1] = (&rtmGetTPtr
|
|
(control_Velocidad_M)[1]);
|
|
control_Velocidad_M->NonInlinedSFcns.taskTimePtrs[2] = (&rtmGetTPtr
|
|
(control_Velocidad_M)[2]);
|
|
rtssSetTPtrPtr(sfcnInfo,control_Velocidad_M->NonInlinedSFcns.taskTimePtrs);
|
|
rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(control_Velocidad_M));
|
|
rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(control_Velocidad_M));
|
|
rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput
|
|
(control_Velocidad_M));
|
|
rtssSetStepSizePtr(sfcnInfo, &control_Velocidad_M->Timing.stepSize);
|
|
rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(control_Velocidad_M));
|
|
rtssSetDerivCacheNeedsResetPtr(sfcnInfo,
|
|
&control_Velocidad_M->derivCacheNeedsReset);
|
|
rtssSetZCCacheNeedsResetPtr(sfcnInfo,
|
|
&control_Velocidad_M->zCCacheNeedsReset);
|
|
rtssSetContTimeOutputInconsistentWithStateAtMajorStepPtr(sfcnInfo,
|
|
&control_Velocidad_M->CTOutputIncnstWithState);
|
|
rtssSetSampleHitsPtr(sfcnInfo, &control_Velocidad_M->Timing.sampleHits);
|
|
rtssSetPerTaskSampleHitsPtr(sfcnInfo,
|
|
&control_Velocidad_M->Timing.perTaskSampleHits);
|
|
rtssSetSimModePtr(sfcnInfo, &control_Velocidad_M->simMode);
|
|
rtssSetSolverInfoPtr(sfcnInfo, &control_Velocidad_M->solverInfoPtr);
|
|
}
|
|
|
|
control_Velocidad_M->Sizes.numSFcns = (3);
|
|
|
|
/* register each child */
|
|
{
|
|
(void) std::memset(static_cast<void *>
|
|
(&control_Velocidad_M->NonInlinedSFcns.childSFunctions[0]),
|
|
0,
|
|
3*sizeof(SimStruct));
|
|
control_Velocidad_M->childSfunctions =
|
|
(&control_Velocidad_M->NonInlinedSFcns.childSFunctionPtrs[0]);
|
|
control_Velocidad_M->childSfunctions[0] =
|
|
(&control_Velocidad_M->NonInlinedSFcns.childSFunctions[0]);
|
|
control_Velocidad_M->childSfunctions[1] =
|
|
(&control_Velocidad_M->NonInlinedSFcns.childSFunctions[1]);
|
|
control_Velocidad_M->childSfunctions[2] =
|
|
(&control_Velocidad_M->NonInlinedSFcns.childSFunctions[2]);
|
|
|
|
/* Level2 S-Function Block: control_Velocidad/<Root>/Digital output (sg_fpga_do_sf_a2) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[0];
|
|
|
|
/* timing info */
|
|
time_T *sfcnPeriod = control_Velocidad_M->NonInlinedSFcns.Sfcn0.sfcnPeriod;
|
|
time_T *sfcnOffset = control_Velocidad_M->NonInlinedSFcns.Sfcn0.sfcnOffset;
|
|
int_T *sfcnTsMap = control_Velocidad_M->NonInlinedSFcns.Sfcn0.sfcnTsMap;
|
|
(void) std::memset(static_cast<void*>(sfcnPeriod), 0,
|
|
sizeof(time_T)*1);
|
|
(void) std::memset(static_cast<void*>(sfcnOffset), 0,
|
|
sizeof(time_T)*1);
|
|
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
|
|
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
|
|
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
|
|
|
|
{
|
|
ssSetBlkInfo2Ptr(rts, &control_Velocidad_M->NonInlinedSFcns.blkInfo2[0]);
|
|
}
|
|
|
|
_ssSetBlkInfo2PortInfo2Ptr(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.inputOutputPortInfo2[0]);
|
|
|
|
/* Set up the mdlInfo pointer */
|
|
ssSetRTWSfcnInfo(rts, control_Velocidad_M->sfcnInfo);
|
|
|
|
/* Allocate memory of model methods 2 */
|
|
{
|
|
ssSetModelMethods2(rts, &control_Velocidad_M->NonInlinedSFcns.methods2[0]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 3 */
|
|
{
|
|
ssSetModelMethods3(rts, &control_Velocidad_M->NonInlinedSFcns.methods3[0]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 4 */
|
|
{
|
|
ssSetModelMethods4(rts, &control_Velocidad_M->NonInlinedSFcns.methods4[0]);
|
|
}
|
|
|
|
/* Allocate memory for states auxilliary information */
|
|
{
|
|
ssSetStatesInfo2(rts, &control_Velocidad_M->NonInlinedSFcns.statesInfo2
|
|
[0]);
|
|
ssSetPeriodicStatesInfo(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.periodicStatesInfo[0]);
|
|
}
|
|
|
|
/* inputs */
|
|
{
|
|
_ssSetNumInputPorts(rts, 6);
|
|
ssSetPortInfoForInputs(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn0.inputPortInfo[0]);
|
|
ssSetPortInfoForInputs(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn0.inputPortInfo[0]);
|
|
_ssSetPortInfo2ForInputUnits(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn0.inputPortUnits[0]);
|
|
ssSetInputPortUnit(rts, 0, 0);
|
|
ssSetInputPortUnit(rts, 1, 0);
|
|
ssSetInputPortUnit(rts, 2, 0);
|
|
ssSetInputPortUnit(rts, 3, 0);
|
|
ssSetInputPortUnit(rts, 4, 0);
|
|
ssSetInputPortUnit(rts, 5, 0);
|
|
_ssSetPortInfo2ForInputCoSimAttribute(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn0.inputPortCoSimAttribute[0]);
|
|
ssSetInputPortIsContinuousQuantity(rts, 0, 0);
|
|
ssSetInputPortIsContinuousQuantity(rts, 1, 0);
|
|
ssSetInputPortIsContinuousQuantity(rts, 2, 0);
|
|
ssSetInputPortIsContinuousQuantity(rts, 3, 0);
|
|
ssSetInputPortIsContinuousQuantity(rts, 4, 0);
|
|
ssSetInputPortIsContinuousQuantity(rts, 5, 0);
|
|
|
|
/* port 0 */
|
|
{
|
|
ssSetInputPortRequiredContiguous(rts, 0, 1);
|
|
ssSetInputPortSignal(rts, 0, &control_Velocidad_B.DataTypeConversion[0]);
|
|
_ssSetInputPortNumDimensions(rts, 0, 1);
|
|
ssSetInputPortWidthAsInt(rts, 0, 1);
|
|
}
|
|
|
|
/* port 1 */
|
|
{
|
|
ssSetInputPortRequiredContiguous(rts, 1, 1);
|
|
ssSetInputPortSignal(rts, 1, &control_Velocidad_B.DataTypeConversion[1]);
|
|
_ssSetInputPortNumDimensions(rts, 1, 1);
|
|
ssSetInputPortWidthAsInt(rts, 1, 1);
|
|
}
|
|
|
|
/* port 2 */
|
|
{
|
|
ssSetInputPortRequiredContiguous(rts, 2, 1);
|
|
ssSetInputPortSignal(rts, 2, &control_Velocidad_B.DataTypeConversion[2]);
|
|
_ssSetInputPortNumDimensions(rts, 2, 1);
|
|
ssSetInputPortWidthAsInt(rts, 2, 1);
|
|
}
|
|
|
|
/* port 3 */
|
|
{
|
|
ssSetInputPortRequiredContiguous(rts, 3, 1);
|
|
ssSetInputPortSignal(rts, 3, &control_Velocidad_B.DataTypeConversion[3]);
|
|
_ssSetInputPortNumDimensions(rts, 3, 1);
|
|
ssSetInputPortWidthAsInt(rts, 3, 1);
|
|
}
|
|
|
|
/* port 4 */
|
|
{
|
|
ssSetInputPortRequiredContiguous(rts, 4, 1);
|
|
ssSetInputPortSignal(rts, 4, &control_Velocidad_B.DataTypeConversion[4]);
|
|
_ssSetInputPortNumDimensions(rts, 4, 1);
|
|
ssSetInputPortWidthAsInt(rts, 4, 1);
|
|
}
|
|
|
|
/* port 5 */
|
|
{
|
|
ssSetInputPortRequiredContiguous(rts, 5, 1);
|
|
ssSetInputPortSignal(rts, 5, &control_Velocidad_B.DataTypeConversion[5]);
|
|
_ssSetInputPortNumDimensions(rts, 5, 1);
|
|
ssSetInputPortWidthAsInt(rts, 5, 1);
|
|
}
|
|
}
|
|
|
|
/* path info */
|
|
ssSetModelName(rts, "Digital output");
|
|
ssSetPath(rts, "control_Velocidad/Digital output");
|
|
ssSetRTModel(rts,control_Velocidad_M);
|
|
ssSetParentSS(rts, (NULL));
|
|
ssSetRootSS(rts, rts);
|
|
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
|
|
|
|
/* parameters */
|
|
{
|
|
mxArray **sfcnParams = (mxArray **)
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn0.params;
|
|
ssSetSFcnParamsCount(rts, 6);
|
|
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
|
|
ssSetSFcnParam(rts, 0, (mxArray*)
|
|
control_Velocidad_cal->Digitaloutput_P1_Size);
|
|
ssSetSFcnParam(rts, 1, (mxArray*)
|
|
control_Velocidad_cal->Digitaloutput_P2_Size);
|
|
ssSetSFcnParam(rts, 2, (mxArray*)
|
|
control_Velocidad_cal->Digitaloutput_P3_Size);
|
|
ssSetSFcnParam(rts, 3, (mxArray*)
|
|
control_Velocidad_cal->Digitaloutput_P4_Size);
|
|
ssSetSFcnParam(rts, 4, (mxArray*)
|
|
control_Velocidad_cal->Digitaloutput_P5_Size);
|
|
ssSetSFcnParam(rts, 5, (mxArray*)
|
|
control_Velocidad_cal->Digitaloutput_P6_Size);
|
|
}
|
|
|
|
/* work vectors */
|
|
ssSetIWork(rts, (int_T *) &control_Velocidad_DW.Digitaloutput_IWORK);
|
|
ssSetPWork(rts, (void **) &control_Velocidad_DW.Digitaloutput_PWORK[0]);
|
|
|
|
{
|
|
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn0.dWork;
|
|
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn0.dWorkAux;
|
|
ssSetSFcnDWork(rts, dWorkRecord);
|
|
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
|
|
ssSetNumDWorkAsInt(rts, 2);
|
|
|
|
/* IWORK */
|
|
ssSetDWorkWidthAsInt(rts, 0, 1);
|
|
ssSetDWorkDataType(rts, 0,SS_INTEGER);
|
|
ssSetDWorkComplexSignal(rts, 0, 0);
|
|
ssSetDWork(rts, 0, &control_Velocidad_DW.Digitaloutput_IWORK);
|
|
|
|
/* PWORK */
|
|
ssSetDWorkWidthAsInt(rts, 1, 2);
|
|
ssSetDWorkDataType(rts, 1,SS_POINTER);
|
|
ssSetDWorkComplexSignal(rts, 1, 0);
|
|
ssSetDWork(rts, 1, &control_Velocidad_DW.Digitaloutput_PWORK[0]);
|
|
}
|
|
|
|
/* registration */
|
|
sg_fpga_do_sf_a2(rts);
|
|
sfcnInitializeSizes(rts);
|
|
sfcnInitializeSampleTimes(rts);
|
|
|
|
/* adjust sample time */
|
|
ssSetSampleTime(rts, 0, 3.8461538461538463E-5);
|
|
ssSetOffsetTime(rts, 0, 0.0);
|
|
sfcnTsMap[0] = 1;
|
|
|
|
/* set compiled values of dynamic vector attributes */
|
|
ssSetNumNonsampledZCsAsInt(rts, 0);
|
|
|
|
/* Update connectivity flags for each port */
|
|
_ssSetInputPortConnected(rts, 0, 1);
|
|
_ssSetInputPortConnected(rts, 1, 1);
|
|
_ssSetInputPortConnected(rts, 2, 1);
|
|
_ssSetInputPortConnected(rts, 3, 1);
|
|
_ssSetInputPortConnected(rts, 4, 1);
|
|
_ssSetInputPortConnected(rts, 5, 1);
|
|
|
|
/* Update the BufferDstPort flags for each input port */
|
|
ssSetInputPortBufferDstPort(rts, 0, -1);
|
|
ssSetInputPortBufferDstPort(rts, 1, -1);
|
|
ssSetInputPortBufferDstPort(rts, 2, -1);
|
|
ssSetInputPortBufferDstPort(rts, 3, -1);
|
|
ssSetInputPortBufferDstPort(rts, 4, -1);
|
|
ssSetInputPortBufferDstPort(rts, 5, -1);
|
|
}
|
|
|
|
/* Level2 S-Function Block: control_Velocidad/<Root>/Digital input (sg_fpga_di_sf_a2) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[1];
|
|
|
|
/* timing info */
|
|
time_T *sfcnPeriod = control_Velocidad_M->NonInlinedSFcns.Sfcn1.sfcnPeriod;
|
|
time_T *sfcnOffset = control_Velocidad_M->NonInlinedSFcns.Sfcn1.sfcnOffset;
|
|
int_T *sfcnTsMap = control_Velocidad_M->NonInlinedSFcns.Sfcn1.sfcnTsMap;
|
|
(void) std::memset(static_cast<void*>(sfcnPeriod), 0,
|
|
sizeof(time_T)*1);
|
|
(void) std::memset(static_cast<void*>(sfcnOffset), 0,
|
|
sizeof(time_T)*1);
|
|
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
|
|
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
|
|
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
|
|
|
|
{
|
|
ssSetBlkInfo2Ptr(rts, &control_Velocidad_M->NonInlinedSFcns.blkInfo2[1]);
|
|
}
|
|
|
|
_ssSetBlkInfo2PortInfo2Ptr(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.inputOutputPortInfo2[1]);
|
|
|
|
/* Set up the mdlInfo pointer */
|
|
ssSetRTWSfcnInfo(rts, control_Velocidad_M->sfcnInfo);
|
|
|
|
/* Allocate memory of model methods 2 */
|
|
{
|
|
ssSetModelMethods2(rts, &control_Velocidad_M->NonInlinedSFcns.methods2[1]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 3 */
|
|
{
|
|
ssSetModelMethods3(rts, &control_Velocidad_M->NonInlinedSFcns.methods3[1]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 4 */
|
|
{
|
|
ssSetModelMethods4(rts, &control_Velocidad_M->NonInlinedSFcns.methods4[1]);
|
|
}
|
|
|
|
/* Allocate memory for states auxilliary information */
|
|
{
|
|
ssSetStatesInfo2(rts, &control_Velocidad_M->NonInlinedSFcns.statesInfo2
|
|
[1]);
|
|
ssSetPeriodicStatesInfo(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.periodicStatesInfo[1]);
|
|
}
|
|
|
|
/* outputs */
|
|
{
|
|
ssSetPortInfoForOutputs(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn1.outputPortInfo[0]);
|
|
ssSetPortInfoForOutputs(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn1.outputPortInfo[0]);
|
|
_ssSetNumOutputPorts(rts, 2);
|
|
_ssSetPortInfo2ForOutputUnits(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn1.outputPortUnits[0]);
|
|
ssSetOutputPortUnit(rts, 0, 0);
|
|
ssSetOutputPortUnit(rts, 1, 0);
|
|
_ssSetPortInfo2ForOutputCoSimAttribute(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn1.outputPortCoSimAttribute[0]);
|
|
ssSetOutputPortIsContinuousQuantity(rts, 0, 0);
|
|
ssSetOutputPortIsContinuousQuantity(rts, 1, 0);
|
|
|
|
/* port 0 */
|
|
{
|
|
_ssSetOutputPortNumDimensions(rts, 0, 1);
|
|
ssSetOutputPortWidthAsInt(rts, 0, 1);
|
|
ssSetOutputPortSignal(rts, 0, ((real_T *)
|
|
&control_Velocidad_B.Digitalinput_o1));
|
|
}
|
|
|
|
/* port 1 */
|
|
{
|
|
_ssSetOutputPortNumDimensions(rts, 1, 1);
|
|
ssSetOutputPortWidthAsInt(rts, 1, 1);
|
|
ssSetOutputPortSignal(rts, 1, ((real_T *)
|
|
&control_Velocidad_B.Digitalinput_o2));
|
|
}
|
|
}
|
|
|
|
/* path info */
|
|
ssSetModelName(rts, "Digital input");
|
|
ssSetPath(rts, "control_Velocidad/Digital input");
|
|
ssSetRTModel(rts,control_Velocidad_M);
|
|
ssSetParentSS(rts, (NULL));
|
|
ssSetRootSS(rts, rts);
|
|
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
|
|
|
|
/* parameters */
|
|
{
|
|
mxArray **sfcnParams = (mxArray **)
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn1.params;
|
|
ssSetSFcnParamsCount(rts, 4);
|
|
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
|
|
ssSetSFcnParam(rts, 0, (mxArray*)
|
|
control_Velocidad_cal->Digitalinput_P1_Size);
|
|
ssSetSFcnParam(rts, 1, (mxArray*)
|
|
control_Velocidad_cal->Digitalinput_P2_Size);
|
|
ssSetSFcnParam(rts, 2, (mxArray*)
|
|
control_Velocidad_cal->Digitalinput_P3_Size);
|
|
ssSetSFcnParam(rts, 3, (mxArray*)
|
|
control_Velocidad_cal->Digitalinput_P4_Size);
|
|
}
|
|
|
|
/* work vectors */
|
|
ssSetPWork(rts, (void **) &control_Velocidad_DW.Digitalinput_PWORK[0]);
|
|
|
|
{
|
|
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn1.dWork;
|
|
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn1.dWorkAux;
|
|
ssSetSFcnDWork(rts, dWorkRecord);
|
|
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
|
|
ssSetNumDWorkAsInt(rts, 1);
|
|
|
|
/* PWORK */
|
|
ssSetDWorkWidthAsInt(rts, 0, 2);
|
|
ssSetDWorkDataType(rts, 0,SS_POINTER);
|
|
ssSetDWorkComplexSignal(rts, 0, 0);
|
|
ssSetDWork(rts, 0, &control_Velocidad_DW.Digitalinput_PWORK[0]);
|
|
}
|
|
|
|
/* registration */
|
|
sg_fpga_di_sf_a2(rts);
|
|
sfcnInitializeSizes(rts);
|
|
sfcnInitializeSampleTimes(rts);
|
|
|
|
/* adjust sample time */
|
|
ssSetSampleTime(rts, 0, 3.8461538461538463E-5);
|
|
ssSetOffsetTime(rts, 0, 0.0);
|
|
sfcnTsMap[0] = 1;
|
|
|
|
/* set compiled values of dynamic vector attributes */
|
|
ssSetNumNonsampledZCsAsInt(rts, 0);
|
|
|
|
/* Update connectivity flags for each port */
|
|
_ssSetOutputPortConnected(rts, 0, 1);
|
|
_ssSetOutputPortConnected(rts, 1, 1);
|
|
_ssSetOutputPortBeingMerged(rts, 0, 0);
|
|
_ssSetOutputPortBeingMerged(rts, 1, 0);
|
|
|
|
/* Update the BufferDstPort flags for each input port */
|
|
}
|
|
|
|
/* Level2 S-Function Block: control_Velocidad/<Root>/IO397 Analog Input (sg_fpga_IO397_ad) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[2];
|
|
|
|
/* timing info */
|
|
time_T *sfcnPeriod = control_Velocidad_M->NonInlinedSFcns.Sfcn2.sfcnPeriod;
|
|
time_T *sfcnOffset = control_Velocidad_M->NonInlinedSFcns.Sfcn2.sfcnOffset;
|
|
int_T *sfcnTsMap = control_Velocidad_M->NonInlinedSFcns.Sfcn2.sfcnTsMap;
|
|
(void) std::memset(static_cast<void*>(sfcnPeriod), 0,
|
|
sizeof(time_T)*1);
|
|
(void) std::memset(static_cast<void*>(sfcnOffset), 0,
|
|
sizeof(time_T)*1);
|
|
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
|
|
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
|
|
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
|
|
|
|
{
|
|
ssSetBlkInfo2Ptr(rts, &control_Velocidad_M->NonInlinedSFcns.blkInfo2[2]);
|
|
}
|
|
|
|
_ssSetBlkInfo2PortInfo2Ptr(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.inputOutputPortInfo2[2]);
|
|
|
|
/* Set up the mdlInfo pointer */
|
|
ssSetRTWSfcnInfo(rts, control_Velocidad_M->sfcnInfo);
|
|
|
|
/* Allocate memory of model methods 2 */
|
|
{
|
|
ssSetModelMethods2(rts, &control_Velocidad_M->NonInlinedSFcns.methods2[2]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 3 */
|
|
{
|
|
ssSetModelMethods3(rts, &control_Velocidad_M->NonInlinedSFcns.methods3[2]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 4 */
|
|
{
|
|
ssSetModelMethods4(rts, &control_Velocidad_M->NonInlinedSFcns.methods4[2]);
|
|
}
|
|
|
|
/* Allocate memory for states auxilliary information */
|
|
{
|
|
ssSetStatesInfo2(rts, &control_Velocidad_M->NonInlinedSFcns.statesInfo2
|
|
[2]);
|
|
ssSetPeriodicStatesInfo(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.periodicStatesInfo[2]);
|
|
}
|
|
|
|
/* outputs */
|
|
{
|
|
ssSetPortInfoForOutputs(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn2.outputPortInfo[0]);
|
|
ssSetPortInfoForOutputs(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn2.outputPortInfo[0]);
|
|
_ssSetNumOutputPorts(rts, 3);
|
|
_ssSetPortInfo2ForOutputUnits(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn2.outputPortUnits[0]);
|
|
ssSetOutputPortUnit(rts, 0, 0);
|
|
ssSetOutputPortUnit(rts, 1, 0);
|
|
ssSetOutputPortUnit(rts, 2, 0);
|
|
_ssSetPortInfo2ForOutputCoSimAttribute(rts,
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn2.outputPortCoSimAttribute[0]);
|
|
ssSetOutputPortIsContinuousQuantity(rts, 0, 0);
|
|
ssSetOutputPortIsContinuousQuantity(rts, 1, 0);
|
|
ssSetOutputPortIsContinuousQuantity(rts, 2, 0);
|
|
|
|
/* port 0 */
|
|
{
|
|
_ssSetOutputPortNumDimensions(rts, 0, 1);
|
|
ssSetOutputPortWidthAsInt(rts, 0, 1);
|
|
ssSetOutputPortSignal(rts, 0, ((real_T *)
|
|
&control_Velocidad_B.IO397AnalogInput_o1));
|
|
}
|
|
|
|
/* port 1 */
|
|
{
|
|
_ssSetOutputPortNumDimensions(rts, 1, 1);
|
|
ssSetOutputPortWidthAsInt(rts, 1, 1);
|
|
ssSetOutputPortSignal(rts, 1, ((real_T *)
|
|
&control_Velocidad_B.IO397AnalogInput_o2));
|
|
}
|
|
|
|
/* port 2 */
|
|
{
|
|
_ssSetOutputPortNumDimensions(rts, 2, 1);
|
|
ssSetOutputPortWidthAsInt(rts, 2, 1);
|
|
ssSetOutputPortSignal(rts, 2, ((real_T *)
|
|
&control_Velocidad_B.IO397AnalogInput_o3));
|
|
}
|
|
}
|
|
|
|
/* path info */
|
|
ssSetModelName(rts, "IO397 Analog Input");
|
|
ssSetPath(rts, "control_Velocidad/IO397 Analog Input");
|
|
ssSetRTModel(rts,control_Velocidad_M);
|
|
ssSetParentSS(rts, (NULL));
|
|
ssSetRootSS(rts, rts);
|
|
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
|
|
|
|
/* parameters */
|
|
{
|
|
mxArray **sfcnParams = (mxArray **)
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn2.params;
|
|
ssSetSFcnParamsCount(rts, 9);
|
|
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
|
|
ssSetSFcnParam(rts, 0, (mxArray*)
|
|
control_Velocidad_cal->IO397AnalogInput_P1_Size);
|
|
ssSetSFcnParam(rts, 1, (mxArray*)
|
|
control_Velocidad_cal->IO397AnalogInput_P2_Size);
|
|
ssSetSFcnParam(rts, 2, (mxArray*)
|
|
control_Velocidad_cal->IO397AnalogInput_P3_Size);
|
|
ssSetSFcnParam(rts, 3, (mxArray*)
|
|
control_Velocidad_cal->IO397AnalogInput_P4_Size);
|
|
ssSetSFcnParam(rts, 4, (mxArray*)
|
|
control_Velocidad_cal->IO397AnalogInput_P5_Size);
|
|
ssSetSFcnParam(rts, 5, (mxArray*)
|
|
control_Velocidad_cal->IO397AnalogInput_P6_Size);
|
|
ssSetSFcnParam(rts, 6, (mxArray*)
|
|
control_Velocidad_cal->IO397AnalogInput_P7_Size);
|
|
ssSetSFcnParam(rts, 7, (mxArray*)
|
|
control_Velocidad_cal->IO397AnalogInput_P8_Size);
|
|
ssSetSFcnParam(rts, 8, (mxArray*)
|
|
control_Velocidad_cal->IO397AnalogInput_P9_Size);
|
|
}
|
|
|
|
/* work vectors */
|
|
ssSetPWork(rts, (void **) &control_Velocidad_DW.IO397AnalogInput_PWORK[0]);
|
|
|
|
{
|
|
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn2.dWork;
|
|
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
|
|
&control_Velocidad_M->NonInlinedSFcns.Sfcn2.dWorkAux;
|
|
ssSetSFcnDWork(rts, dWorkRecord);
|
|
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
|
|
ssSetNumDWorkAsInt(rts, 1);
|
|
|
|
/* PWORK */
|
|
ssSetDWorkWidthAsInt(rts, 0, 3);
|
|
ssSetDWorkDataType(rts, 0,SS_POINTER);
|
|
ssSetDWorkComplexSignal(rts, 0, 0);
|
|
ssSetDWork(rts, 0, &control_Velocidad_DW.IO397AnalogInput_PWORK[0]);
|
|
}
|
|
|
|
/* registration */
|
|
sg_fpga_IO397_ad(rts);
|
|
sfcnInitializeSizes(rts);
|
|
sfcnInitializeSampleTimes(rts);
|
|
|
|
/* adjust sample time */
|
|
ssSetSampleTime(rts, 0, 0.001);
|
|
ssSetOffsetTime(rts, 0, 0.0);
|
|
sfcnTsMap[0] = 2;
|
|
|
|
/* set compiled values of dynamic vector attributes */
|
|
ssSetNumNonsampledZCsAsInt(rts, 0);
|
|
|
|
/* Update connectivity flags for each port */
|
|
_ssSetOutputPortConnected(rts, 0, 1);
|
|
_ssSetOutputPortConnected(rts, 1, 1);
|
|
_ssSetOutputPortConnected(rts, 2, 1);
|
|
_ssSetOutputPortBeingMerged(rts, 0, 0);
|
|
_ssSetOutputPortBeingMerged(rts, 1, 0);
|
|
_ssSetOutputPortBeingMerged(rts, 2, 0);
|
|
|
|
/* Update the BufferDstPort flags for each input port */
|
|
}
|
|
}
|
|
|
|
/* Start for S-Function (sg_fpga_do_sf_a2): '<Root>/Digital output' */
|
|
/* Level2 S-Function Block: '<Root>/Digital output' (sg_fpga_do_sf_a2) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[0];
|
|
sfcnStart(rts);
|
|
if (ssGetErrorStatus(rts) != (NULL))
|
|
return;
|
|
}
|
|
|
|
/* Start for S-Function (sg_fpga_di_sf_a2): '<Root>/Digital input' */
|
|
/* Level2 S-Function Block: '<Root>/Digital input' (sg_fpga_di_sf_a2) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[1];
|
|
sfcnStart(rts);
|
|
if (ssGetErrorStatus(rts) != (NULL))
|
|
return;
|
|
}
|
|
|
|
/* Start for S-Function (sg_fpga_IO397_ad): '<Root>/IO397 Analog Input' */
|
|
/* Level2 S-Function Block: '<Root>/IO397 Analog Input' (sg_fpga_IO397_ad) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[2];
|
|
sfcnStart(rts);
|
|
if (ssGetErrorStatus(rts) != (NULL))
|
|
return;
|
|
}
|
|
|
|
control_Velocidad_PrevZCX.TriggeredSubsystem_Trig_ZCE = POS_ZCSIG;
|
|
control_Velocidad_PrevZCX.SampleandHold1_Trig_ZCE = POS_ZCSIG;
|
|
|
|
/* InitializeConditions for DiscreteIntegrator: '<S1>/Discrete-Time Integrator' */
|
|
control_Velocidad_DW.DiscreteTimeIntegrator_DSTATE =
|
|
control_Velocidad_cal->DiscreteTimeIntegrator_IC;
|
|
|
|
/* InitializeConditions for Delay: '<S3>/Delay1' */
|
|
control_Velocidad_DW.Delay1_DSTATE =
|
|
control_Velocidad_cal->Delay1_InitialCondition;
|
|
|
|
/* InitializeConditions for Memory: '<S17>/Memory' */
|
|
control_Velocidad_DW.Memory_PreviousInput =
|
|
control_Velocidad_cal->EdgeDetector_ic;
|
|
|
|
/* InitializeConditions for UnitDelay: '<S14>/UD' */
|
|
control_Velocidad_DW.UD_DSTATE =
|
|
control_Velocidad_cal->Difference1_ICPrevInput;
|
|
|
|
/* InitializeConditions for Delay: '<S3>/Delay' */
|
|
control_Velocidad_DW.Delay_DSTATE =
|
|
control_Velocidad_cal->Delay_InitialCondition;
|
|
|
|
/* SystemInitialize for Triggered SubSystem: '<S18>/Triggered Subsystem' */
|
|
/* SystemInitialize for SignalConversion generated from: '<S21>/In1' incorporates:
|
|
* Outport: '<S21>/Out1'
|
|
*/
|
|
control_Velocidad_B.In1 = control_Velocidad_cal->Out1_Y0;
|
|
|
|
/* End of SystemInitialize for SubSystem: '<S18>/Triggered Subsystem' */
|
|
|
|
/* SystemInitialize for Enabled SubSystem: '<S17>/NEGATIVE Edge' */
|
|
/* SystemInitialize for RelationalOperator: '<S19>/Relational Operator1' incorporates:
|
|
* Outport: '<S19>/OUT'
|
|
*/
|
|
control_Velocidad_B.RelationalOperator1_e = control_Velocidad_cal->OUT_Y0;
|
|
|
|
/* End of SystemInitialize for SubSystem: '<S17>/NEGATIVE Edge' */
|
|
|
|
/* SystemInitialize for Enabled SubSystem: '<S17>/POSITIVE Edge' */
|
|
/* SystemInitialize for RelationalOperator: '<S20>/Relational Operator1' incorporates:
|
|
* Outport: '<S20>/OUT'
|
|
*/
|
|
control_Velocidad_B.RelationalOperator1 = control_Velocidad_cal->OUT_Y0_p;
|
|
|
|
/* End of SystemInitialize for SubSystem: '<S17>/POSITIVE Edge' */
|
|
|
|
/* SystemInitialize for Triggered SubSystem: '<S3>/Sample and Hold1' */
|
|
/* SystemInitialize for SignalConversion generated from: '<S16>/In' incorporates:
|
|
* Outport: '<S16>/ '
|
|
*/
|
|
control_Velocidad_B.In = control_Velocidad_cal->_Y0;
|
|
|
|
/* End of SystemInitialize for SubSystem: '<S3>/Sample and Hold1' */
|
|
}
|
|
|
|
/* Model terminate function */
|
|
void control_Velocidad_terminate(void)
|
|
{
|
|
/* Terminate for S-Function (sg_fpga_do_sf_a2): '<Root>/Digital output' */
|
|
/* Level2 S-Function Block: '<Root>/Digital output' (sg_fpga_do_sf_a2) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[0];
|
|
sfcnTerminate(rts);
|
|
}
|
|
|
|
/* Terminate for S-Function (sg_fpga_di_sf_a2): '<Root>/Digital input' */
|
|
/* Level2 S-Function Block: '<Root>/Digital input' (sg_fpga_di_sf_a2) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[1];
|
|
sfcnTerminate(rts);
|
|
}
|
|
|
|
/* Terminate for S-Function (sg_fpga_IO397_ad): '<Root>/IO397 Analog Input' */
|
|
/* Level2 S-Function Block: '<Root>/IO397 Analog Input' (sg_fpga_IO397_ad) */
|
|
{
|
|
SimStruct *rts = control_Velocidad_M->childSfunctions[2];
|
|
sfcnTerminate(rts);
|
|
}
|
|
|
|
/* user code (Terminate function Trailer) */
|
|
{
|
|
freeFPGAModuleSgLib((uint32_t)1);
|
|
}
|
|
}
|