mirror of
https://github.com/Dev-KATECH/ADM.git
synced 2026-05-17 01:43:59 +09:00
2043 lines
67 KiB
C
2043 lines
67 KiB
C
/*
|
|
* CANTest.c
|
|
*
|
|
* 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 "CANTest".
|
|
*
|
|
* Model version : 1.360
|
|
* Simulink Coder version : 8.14 (R2018a) 06-Feb-2018
|
|
* C source code generated on : Tue Jul 11 11:56:08 2023
|
|
*
|
|
* Target selection: slrt.tlc
|
|
* Note: GRT includes extra infrastructure and instrumentation for prototyping
|
|
* Embedded hardware selection: Generic->32-bit x86 compatible
|
|
* Code generation objectives: Unspecified
|
|
* Validation result: Not run
|
|
*/
|
|
|
|
#include "rt_logging_mmi.h"
|
|
#include "CANTest_capi.h"
|
|
#include "CANTest.h"
|
|
#include "CANTest_private.h"
|
|
|
|
/* Block signals (default storage) */
|
|
B_CANTest_T CANTest_B;
|
|
|
|
/* Block states (default storage) */
|
|
DW_CANTest_T CANTest_DW;
|
|
|
|
/* Real-time model */
|
|
RT_MODEL_CANTest_T CANTest_M_;
|
|
RT_MODEL_CANTest_T *const CANTest_M = &CANTest_M_;
|
|
|
|
/* Model output function */
|
|
static void CANTest_output(void)
|
|
{
|
|
int32_T s1_iter;
|
|
|
|
/* Gain: '<S4>/ContM' incorporates:
|
|
* Constant: '<S4>/ContMode'
|
|
*/
|
|
CANTest_B.ContMode = CANTest_P.ContM_Gain * CANTest_P.ContMode_Value;
|
|
|
|
/* Constant: '<S5>/Constant' */
|
|
CANTest_B.Ready = CANTest_P.Constant_Value;
|
|
|
|
/* Constant: '<S5>/Constant1' */
|
|
CANTest_B.Gear = CANTest_P.Constant1_Value;
|
|
|
|
/* Constant: '<S5>/Constant2' */
|
|
CANTest_B.BMS = CANTest_P.Constant2_Value;
|
|
|
|
/* Constant: '<S5>/Constant3' */
|
|
CANTest_B.PosTQLim = CANTest_P.Constant3_Value;
|
|
|
|
/* Constant: '<S5>/Constant4' */
|
|
CANTest_B.NegTQLim = CANTest_P.Constant4_Value;
|
|
|
|
/* UnitDelay: '<S6>/d1' */
|
|
CANTest_B.d1 = CANTest_DW.d1_DSTATE;
|
|
|
|
/* Sum: '<S6>/Sum3' incorporates:
|
|
* Constant: '<S4>/TQCom'
|
|
*/
|
|
CANTest_B.Sum3 = CANTest_P.TQCom_Value + CANTest_B.d1;
|
|
|
|
/* Gain: '<S6>/gain' */
|
|
CANTest_B.gain = CANTest_P.Ts * CANTest_B.Sum3;
|
|
|
|
/* Gain: '<S6>/gain2' incorporates:
|
|
* Constant: '<S4>/Constant1'
|
|
*/
|
|
CANTest_B.gain2 = CANTest_P.gain2_Gain * CANTest_P.Constant1_Value_j;
|
|
|
|
/* Product: '<S6>/Product2' incorporates:
|
|
* Constant: '<S6>/Constant1'
|
|
*/
|
|
CANTest_B.Product2 = CANTest_P.Constant1_Value_a / CANTest_B.gain2;
|
|
|
|
/* Gain: '<S6>/gain1' */
|
|
CANTest_B.gain1 = CANTest_P.gain1_Gain * CANTest_B.Product2;
|
|
|
|
/* Sum: '<S6>/Sum1' incorporates:
|
|
* Constant: '<S6>/Constant'
|
|
*/
|
|
CANTest_B.Sum1 = CANTest_B.gain1 - CANTest_P.Ts;
|
|
|
|
/* UnitDelay: '<S6>/d' */
|
|
CANTest_B.d = CANTest_DW.d_DSTATE;
|
|
|
|
/* Product: '<S6>/Product11' */
|
|
CANTest_B.Product11 = CANTest_B.Sum1 * CANTest_B.d;
|
|
|
|
/* Sum: '<S6>/Sum2' */
|
|
CANTest_B.Sum2 = CANTest_B.gain + CANTest_B.Product11;
|
|
|
|
/* Sum: '<S6>/Sum4' incorporates:
|
|
* Constant: '<S6>/Constant'
|
|
*/
|
|
CANTest_B.Sum4 = CANTest_B.gain1 + CANTest_P.Ts;
|
|
|
|
/* Product: '<S6>/Product1' */
|
|
CANTest_B.Product1 = CANTest_B.Sum2 / CANTest_B.Sum4;
|
|
|
|
/* S-Function (scanpack): '<S5>/CAN Pack' */
|
|
/* S-Function (scanpack): '<S5>/CAN Pack' */
|
|
CANTest_B.CANPack.ID = 592U;
|
|
CANTest_B.CANPack.Length = 8U;
|
|
CANTest_B.CANPack.Extended = 0U;
|
|
CANTest_B.CANPack.Remote = 0;
|
|
CANTest_B.CANPack.Data[0] = 0;
|
|
CANTest_B.CANPack.Data[1] = 0;
|
|
CANTest_B.CANPack.Data[2] = 0;
|
|
CANTest_B.CANPack.Data[3] = 0;
|
|
CANTest_B.CANPack.Data[4] = 0;
|
|
CANTest_B.CANPack.Data[5] = 0;
|
|
CANTest_B.CANPack.Data[6] = 0;
|
|
CANTest_B.CANPack.Data[7] = 0;
|
|
|
|
{
|
|
/* --------------- START Packing signal 0 ------------------
|
|
* startBit = 0
|
|
* length = 1
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 1.0
|
|
* offset = 0.0
|
|
* minimum = 0.0
|
|
* maximum = 0.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
real64_T result = CANTest_B.ContMode;
|
|
|
|
/* no scaling required */
|
|
outValue = result;
|
|
}
|
|
|
|
{
|
|
{
|
|
uint8_T packedValue;
|
|
if (outValue > (real64_T)(1)) {
|
|
packedValue = (uint8_T) 1;
|
|
} else if (outValue < (real64_T)(0)) {
|
|
packedValue = (uint8_T) 0;
|
|
} else {
|
|
packedValue = (uint8_T) (outValue);
|
|
}
|
|
|
|
{
|
|
{
|
|
CANTest_B.CANPack.Data[0] = CANTest_B.CANPack.Data[0] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
0)) >> 0)<<0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------- START Packing signal 1 ------------------
|
|
* startBit = 1
|
|
* length = 1
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 1.0
|
|
* offset = 0.0
|
|
* minimum = 0.0
|
|
* maximum = 0.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
real64_T result = CANTest_B.Ready;
|
|
|
|
/* no scaling required */
|
|
outValue = result;
|
|
}
|
|
|
|
{
|
|
{
|
|
uint8_T packedValue;
|
|
if (outValue > (real64_T)(1)) {
|
|
packedValue = (uint8_T) 1;
|
|
} else if (outValue < (real64_T)(0)) {
|
|
packedValue = (uint8_T) 0;
|
|
} else {
|
|
packedValue = (uint8_T) (outValue);
|
|
}
|
|
|
|
{
|
|
{
|
|
CANTest_B.CANPack.Data[0] = CANTest_B.CANPack.Data[0] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
0)) >> 0)<<1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------- START Packing signal 2 ------------------
|
|
* startBit = 2
|
|
* length = 1
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 1.0
|
|
* offset = 0.0
|
|
* minimum = 0.0
|
|
* maximum = 0.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
real64_T result = CANTest_B.Ready;
|
|
|
|
/* no scaling required */
|
|
outValue = result;
|
|
}
|
|
|
|
{
|
|
{
|
|
uint8_T packedValue;
|
|
if (outValue > (real64_T)(1)) {
|
|
packedValue = (uint8_T) 1;
|
|
} else if (outValue < (real64_T)(0)) {
|
|
packedValue = (uint8_T) 0;
|
|
} else {
|
|
packedValue = (uint8_T) (outValue);
|
|
}
|
|
|
|
{
|
|
{
|
|
CANTest_B.CANPack.Data[0] = CANTest_B.CANPack.Data[0] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
0)) >> 0)<<2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------- START Packing signal 3 ------------------
|
|
* startBit = 3
|
|
* length = 1
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 1.0
|
|
* offset = 0.0
|
|
* minimum = 0.0
|
|
* maximum = 0.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
real64_T result = CANTest_B.Ready;
|
|
|
|
/* no scaling required */
|
|
outValue = result;
|
|
}
|
|
|
|
{
|
|
{
|
|
uint8_T packedValue;
|
|
if (outValue > (real64_T)(1)) {
|
|
packedValue = (uint8_T) 1;
|
|
} else if (outValue < (real64_T)(0)) {
|
|
packedValue = (uint8_T) 0;
|
|
} else {
|
|
packedValue = (uint8_T) (outValue);
|
|
}
|
|
|
|
{
|
|
{
|
|
CANTest_B.CANPack.Data[0] = CANTest_B.CANPack.Data[0] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
0)) >> 0)<<3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------- START Packing signal 4 ------------------
|
|
* startBit = 4
|
|
* length = 4
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 1.0
|
|
* offset = 0.0
|
|
* minimum = 0.0
|
|
* maximum = 0.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
real64_T result = CANTest_B.Gear;
|
|
|
|
/* no scaling required */
|
|
outValue = result;
|
|
}
|
|
|
|
{
|
|
{
|
|
uint8_T packedValue;
|
|
if (outValue > (real64_T)(15)) {
|
|
packedValue = (uint8_T) 15;
|
|
} else if (outValue < (real64_T)(0)) {
|
|
packedValue = (uint8_T) 0;
|
|
} else {
|
|
packedValue = (uint8_T) (outValue);
|
|
}
|
|
|
|
{
|
|
{
|
|
CANTest_B.CANPack.Data[0] = CANTest_B.CANPack.Data[0] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
0)) >> 0)<<4);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[0] = CANTest_B.CANPack.Data[0] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
1)) >> 1)<<5);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[0] = CANTest_B.CANPack.Data[0] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
2)) >> 2)<<6);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[0] = CANTest_B.CANPack.Data[0] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
3)) >> 3)<<7);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------- START Packing signal 5 ------------------
|
|
* startBit = 8
|
|
* length = 2
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 1.0
|
|
* offset = 0.0
|
|
* minimum = 0.0
|
|
* maximum = 0.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
real64_T result = CANTest_B.Ready;
|
|
|
|
/* no scaling required */
|
|
outValue = result;
|
|
}
|
|
|
|
{
|
|
{
|
|
uint8_T packedValue;
|
|
if (outValue > (real64_T)(3)) {
|
|
packedValue = (uint8_T) 3;
|
|
} else if (outValue < (real64_T)(0)) {
|
|
packedValue = (uint8_T) 0;
|
|
} else {
|
|
packedValue = (uint8_T) (outValue);
|
|
}
|
|
|
|
{
|
|
{
|
|
CANTest_B.CANPack.Data[1] = CANTest_B.CANPack.Data[1] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
0)) >> 0)<<0);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[1] = CANTest_B.CANPack.Data[1] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
1)) >> 1)<<1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------- START Packing signal 6 ------------------
|
|
* startBit = 10
|
|
* length = 3
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 1.0
|
|
* offset = 0.0
|
|
* minimum = 0.0
|
|
* maximum = 0.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
real64_T result = CANTest_B.BMS;
|
|
|
|
/* no scaling required */
|
|
outValue = result;
|
|
}
|
|
|
|
{
|
|
{
|
|
uint8_T packedValue;
|
|
if (outValue > (real64_T)(7)) {
|
|
packedValue = (uint8_T) 7;
|
|
} else if (outValue < (real64_T)(0)) {
|
|
packedValue = (uint8_T) 0;
|
|
} else {
|
|
packedValue = (uint8_T) (outValue);
|
|
}
|
|
|
|
{
|
|
{
|
|
CANTest_B.CANPack.Data[1] = CANTest_B.CANPack.Data[1] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
0)) >> 0)<<2);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[1] = CANTest_B.CANPack.Data[1] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
1)) >> 1)<<3);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[1] = CANTest_B.CANPack.Data[1] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
2)) >> 2)<<4);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------- START Packing signal 7 ------------------
|
|
* startBit = 13
|
|
* length = 2
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 1.0
|
|
* offset = 0.0
|
|
* minimum = 0.0
|
|
* maximum = 0.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
real64_T result = CANTest_B.Ready;
|
|
|
|
/* no scaling required */
|
|
outValue = result;
|
|
}
|
|
|
|
{
|
|
{
|
|
uint8_T packedValue;
|
|
if (outValue > (real64_T)(3)) {
|
|
packedValue = (uint8_T) 3;
|
|
} else if (outValue < (real64_T)(0)) {
|
|
packedValue = (uint8_T) 0;
|
|
} else {
|
|
packedValue = (uint8_T) (outValue);
|
|
}
|
|
|
|
{
|
|
{
|
|
CANTest_B.CANPack.Data[1] = CANTest_B.CANPack.Data[1] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
0)) >> 0)<<5);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[1] = CANTest_B.CANPack.Data[1] | (uint8_T)
|
|
((uint8_T)((uint8_T)(packedValue & (uint8_T)(((uint8_T)(1)) <<
|
|
1)) >> 1)<<6);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------- START Packing signal 8 ------------------
|
|
* startBit = 16
|
|
* length = 16
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 0.1
|
|
* offset = -200.0
|
|
* minimum = 0.0
|
|
* maximum = 0.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
real64_T result = CANTest_B.PosTQLim;
|
|
|
|
/* full scaling operation */
|
|
result = (result - -200.0) * (1 / 0.1);
|
|
outValue = result;
|
|
}
|
|
|
|
{
|
|
{
|
|
uint16_T packedValue;
|
|
if (outValue > (real64_T)(65535)) {
|
|
packedValue = (uint16_T) 65535;
|
|
} else if (outValue < (real64_T)(0)) {
|
|
packedValue = (uint16_T) 0;
|
|
} else {
|
|
packedValue = (uint16_T) (outValue);
|
|
}
|
|
|
|
{
|
|
{
|
|
CANTest_B.CANPack.Data[2] = CANTest_B.CANPack.Data[2] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 0)) >> 0)<<0);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[2] = CANTest_B.CANPack.Data[2] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 1)) >> 1)<<1);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[2] = CANTest_B.CANPack.Data[2] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 2)) >> 2)<<2);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[2] = CANTest_B.CANPack.Data[2] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 3)) >> 3)<<3);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[2] = CANTest_B.CANPack.Data[2] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 4)) >> 4)<<4);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[2] = CANTest_B.CANPack.Data[2] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 5)) >> 5)<<5);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[2] = CANTest_B.CANPack.Data[2] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 6)) >> 6)<<6);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[2] = CANTest_B.CANPack.Data[2] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 7)) >> 7)<<7);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[3] = CANTest_B.CANPack.Data[3] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 8)) >> 8)<<0);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[3] = CANTest_B.CANPack.Data[3] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 9)) >> 9)<<1);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[3] = CANTest_B.CANPack.Data[3] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 10)) >> 10)<<2);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[3] = CANTest_B.CANPack.Data[3] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 11)) >> 11)<<3);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[3] = CANTest_B.CANPack.Data[3] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 12)) >> 12)<<4);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[3] = CANTest_B.CANPack.Data[3] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 13)) >> 13)<<5);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[3] = CANTest_B.CANPack.Data[3] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 14)) >> 14)<<6);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[3] = CANTest_B.CANPack.Data[3] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 15)) >> 15)<<7);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------- START Packing signal 9 ------------------
|
|
* startBit = 32
|
|
* length = 16
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 0.1
|
|
* offset = -200.0
|
|
* minimum = 0.0
|
|
* maximum = 0.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
real64_T result = CANTest_B.NegTQLim;
|
|
|
|
/* full scaling operation */
|
|
result = (result - -200.0) * (1 / 0.1);
|
|
outValue = result;
|
|
}
|
|
|
|
{
|
|
{
|
|
uint16_T packedValue;
|
|
if (outValue > (real64_T)(65535)) {
|
|
packedValue = (uint16_T) 65535;
|
|
} else if (outValue < (real64_T)(0)) {
|
|
packedValue = (uint16_T) 0;
|
|
} else {
|
|
packedValue = (uint16_T) (outValue);
|
|
}
|
|
|
|
{
|
|
{
|
|
CANTest_B.CANPack.Data[4] = CANTest_B.CANPack.Data[4] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 0)) >> 0)<<0);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[4] = CANTest_B.CANPack.Data[4] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 1)) >> 1)<<1);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[4] = CANTest_B.CANPack.Data[4] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 2)) >> 2)<<2);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[4] = CANTest_B.CANPack.Data[4] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 3)) >> 3)<<3);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[4] = CANTest_B.CANPack.Data[4] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 4)) >> 4)<<4);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[4] = CANTest_B.CANPack.Data[4] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 5)) >> 5)<<5);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[4] = CANTest_B.CANPack.Data[4] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 6)) >> 6)<<6);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[4] = CANTest_B.CANPack.Data[4] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 7)) >> 7)<<7);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[5] = CANTest_B.CANPack.Data[5] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 8)) >> 8)<<0);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[5] = CANTest_B.CANPack.Data[5] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 9)) >> 9)<<1);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[5] = CANTest_B.CANPack.Data[5] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 10)) >> 10)<<2);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[5] = CANTest_B.CANPack.Data[5] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 11)) >> 11)<<3);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[5] = CANTest_B.CANPack.Data[5] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 12)) >> 12)<<4);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[5] = CANTest_B.CANPack.Data[5] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 13)) >> 13)<<5);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[5] = CANTest_B.CANPack.Data[5] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 14)) >> 14)<<6);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[5] = CANTest_B.CANPack.Data[5] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 15)) >> 15)<<7);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------- START Packing signal 10 ------------------
|
|
* startBit = 48
|
|
* length = 16
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 0.1
|
|
* offset = -200.0
|
|
* minimum = 0.0
|
|
* maximum = 0.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
real64_T result = CANTest_B.Product1;
|
|
|
|
/* full scaling operation */
|
|
result = (result - -200.0) * (1 / 0.1);
|
|
outValue = result;
|
|
}
|
|
|
|
{
|
|
{
|
|
uint16_T packedValue;
|
|
if (outValue > (real64_T)(65535)) {
|
|
packedValue = (uint16_T) 65535;
|
|
} else if (outValue < (real64_T)(0)) {
|
|
packedValue = (uint16_T) 0;
|
|
} else {
|
|
packedValue = (uint16_T) (outValue);
|
|
}
|
|
|
|
{
|
|
{
|
|
CANTest_B.CANPack.Data[6] = CANTest_B.CANPack.Data[6] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 0)) >> 0)<<0);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[6] = CANTest_B.CANPack.Data[6] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 1)) >> 1)<<1);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[6] = CANTest_B.CANPack.Data[6] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 2)) >> 2)<<2);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[6] = CANTest_B.CANPack.Data[6] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 3)) >> 3)<<3);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[6] = CANTest_B.CANPack.Data[6] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 4)) >> 4)<<4);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[6] = CANTest_B.CANPack.Data[6] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 5)) >> 5)<<5);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[6] = CANTest_B.CANPack.Data[6] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 6)) >> 6)<<6);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[6] = CANTest_B.CANPack.Data[6] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 7)) >> 7)<<7);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[7] = CANTest_B.CANPack.Data[7] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 8)) >> 8)<<0);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[7] = CANTest_B.CANPack.Data[7] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 9)) >> 9)<<1);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[7] = CANTest_B.CANPack.Data[7] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 10)) >> 10)<<2);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[7] = CANTest_B.CANPack.Data[7] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 11)) >> 11)<<3);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[7] = CANTest_B.CANPack.Data[7] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 12)) >> 12)<<4);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[7] = CANTest_B.CANPack.Data[7] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 13)) >> 13)<<5);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[7] = CANTest_B.CANPack.Data[7] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 14)) >> 14)<<6);
|
|
}
|
|
|
|
{
|
|
CANTest_B.CANPack.Data[7] = CANTest_B.CANPack.Data[7] | (uint8_T)
|
|
((uint8_T)((uint16_T)(packedValue & (uint16_T)(((uint16_T)(1))
|
|
<< 15)) >> 15)<<7);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* S-Function (sg_IO61X_write_s): '<S5>/CAN Write1' */
|
|
|
|
/* Level2 S-Function Block: '<S5>/CAN Write1' (sg_IO61X_write_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[2];
|
|
sfcnOutputs(rts,0);
|
|
}
|
|
|
|
/* Outputs for Iterator SubSystem: '<Root>/DAQ_In' incorporates:
|
|
* WhileIterator: '<S1>/While Iterator'
|
|
*/
|
|
s1_iter = 1;
|
|
do {
|
|
/* Level2 S-Function Block: '<S1>/CAN Setup' (sg_IO613_setup_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[0];
|
|
sfcnOutputs(rts,0);
|
|
}
|
|
|
|
/* Level2 S-Function Block: '<S1>/CAN Read1' (sg_IO61X_read_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[1];
|
|
sfcnOutputs(rts,0);
|
|
}
|
|
|
|
{
|
|
/* S-Function (scanunpack): '<S1>/CAN Unpack2' */
|
|
if ((8 == CANTest_B.CANRead1_o2.Length) && (CANTest_B.CANRead1_o2.ID !=
|
|
INVALID_CAN_ID) ) {
|
|
if ((768U == CANTest_B.CANRead1_o2.ID) && (0U ==
|
|
CANTest_B.CANRead1_o2.Extended) ) {
|
|
{
|
|
/* --------------- START Unpacking signal 0 ------------------
|
|
* startBit = 32
|
|
* length = 16
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 1.0
|
|
* offset = -32768.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
{
|
|
uint16_T unpackedValue = 0;
|
|
|
|
{
|
|
uint16_T tempValue = (uint16_T) (0);
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[4]) & (uint16_T)
|
|
( (uint16_T) (1)<< 0)) >> 0)<<0);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[4]) & (uint16_T)
|
|
( (uint16_T) (1)<< 1)) >> 1)<<1);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[4]) & (uint16_T)
|
|
( (uint16_T) (1)<< 2)) >> 2)<<2);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[4]) & (uint16_T)
|
|
( (uint16_T) (1)<< 3)) >> 3)<<3);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[4]) & (uint16_T)
|
|
( (uint16_T) (1)<< 4)) >> 4)<<4);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[4]) & (uint16_T)
|
|
( (uint16_T) (1)<< 5)) >> 5)<<5);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[4]) & (uint16_T)
|
|
( (uint16_T) (1)<< 6)) >> 6)<<6);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[4]) & (uint16_T)
|
|
( (uint16_T) (1)<< 7)) >> 7)<<7);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[5]) & (uint16_T)
|
|
( (uint16_T) (1)<< 0)) >> 0)<<8);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[5]) & (uint16_T)
|
|
( (uint16_T) (1)<< 1)) >> 1)<<9);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[5]) & (uint16_T)
|
|
( (uint16_T) (1)<< 2)) >> 2)<<10);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[5]) & (uint16_T)
|
|
( (uint16_T) (1)<< 3)) >> 3)<<11);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[5]) & (uint16_T)
|
|
( (uint16_T) (1)<< 4)) >> 4)<<12);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[5]) & (uint16_T)
|
|
( (uint16_T) (1)<< 5)) >> 5)<<13);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[5]) & (uint16_T)
|
|
( (uint16_T) (1)<< 6)) >> 6)<<14);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[5]) & (uint16_T)
|
|
( (uint16_T) (1)<< 7)) >> 7)<<15);
|
|
}
|
|
|
|
unpackedValue = tempValue;
|
|
}
|
|
|
|
outValue = (real64_T) (unpackedValue);
|
|
}
|
|
}
|
|
|
|
{
|
|
real64_T result = (real64_T) outValue;
|
|
result = result + -32768.0;
|
|
CANTest_B.RPM = result;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* --------------- START Unpacking signal 1 ------------------
|
|
* startBit = 48
|
|
* length = 16
|
|
* desiredSignalByteLayout = LITTLEENDIAN
|
|
* dataType = UNSIGNED
|
|
* factor = 0.1
|
|
* offset = -200.0
|
|
* -----------------------------------------------------------------------*/
|
|
{
|
|
{
|
|
real64_T outValue = 0;
|
|
|
|
{
|
|
{
|
|
uint16_T unpackedValue = 0;
|
|
|
|
{
|
|
uint16_T tempValue = (uint16_T) (0);
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[6]) & (uint16_T)
|
|
( (uint16_T) (1)<< 0)) >> 0)<<0);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[6]) & (uint16_T)
|
|
( (uint16_T) (1)<< 1)) >> 1)<<1);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[6]) & (uint16_T)
|
|
( (uint16_T) (1)<< 2)) >> 2)<<2);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[6]) & (uint16_T)
|
|
( (uint16_T) (1)<< 3)) >> 3)<<3);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[6]) & (uint16_T)
|
|
( (uint16_T) (1)<< 4)) >> 4)<<4);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[6]) & (uint16_T)
|
|
( (uint16_T) (1)<< 5)) >> 5)<<5);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[6]) & (uint16_T)
|
|
( (uint16_T) (1)<< 6)) >> 6)<<6);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[6]) & (uint16_T)
|
|
( (uint16_T) (1)<< 7)) >> 7)<<7);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[7]) & (uint16_T)
|
|
( (uint16_T) (1)<< 0)) >> 0)<<8);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[7]) & (uint16_T)
|
|
( (uint16_T) (1)<< 1)) >> 1)<<9);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[7]) & (uint16_T)
|
|
( (uint16_T) (1)<< 2)) >> 2)<<10);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[7]) & (uint16_T)
|
|
( (uint16_T) (1)<< 3)) >> 3)<<11);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[7]) & (uint16_T)
|
|
( (uint16_T) (1)<< 4)) >> 4)<<12);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[7]) & (uint16_T)
|
|
( (uint16_T) (1)<< 5)) >> 5)<<13);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[7]) & (uint16_T)
|
|
( (uint16_T) (1)<< 6)) >> 6)<<14);
|
|
}
|
|
|
|
{
|
|
tempValue = tempValue | (uint16_T)((uint16_T)((uint16_T)
|
|
((CANTest_B.CANRead1_o2.Data[7]) & (uint16_T)
|
|
( (uint16_T) (1)<< 7)) >> 7)<<15);
|
|
}
|
|
|
|
unpackedValue = tempValue;
|
|
}
|
|
|
|
outValue = (real64_T) (unpackedValue);
|
|
}
|
|
}
|
|
|
|
{
|
|
real64_T result = (real64_T) outValue;
|
|
result = (result * 0.1) + -200.0;
|
|
CANTest_B.TQ = result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
s1_iter++;
|
|
} while (CANTest_B.CANRead1_o1 && (s1_iter <= 501));
|
|
|
|
/* End of Outputs for SubSystem: '<Root>/DAQ_In' */
|
|
}
|
|
|
|
/* Model update function */
|
|
static void CANTest_update(void)
|
|
{
|
|
/* Update for UnitDelay: '<S6>/d1' incorporates:
|
|
* Constant: '<S4>/TQCom'
|
|
*/
|
|
CANTest_DW.d1_DSTATE = CANTest_P.TQCom_Value;
|
|
|
|
/* Update for UnitDelay: '<S6>/d' */
|
|
CANTest_DW.d_DSTATE = CANTest_B.Product1;
|
|
|
|
/* Update absolute time for base rate */
|
|
/* 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 (!(++CANTest_M->Timing.clockTick0)) {
|
|
++CANTest_M->Timing.clockTickH0;
|
|
}
|
|
|
|
CANTest_M->Timing.t[0] = CANTest_M->Timing.clockTick0 *
|
|
CANTest_M->Timing.stepSize0 + CANTest_M->Timing.clockTickH0 *
|
|
CANTest_M->Timing.stepSize0 * 4294967296.0;
|
|
}
|
|
|
|
/* Model initialize function */
|
|
static void CANTest_initialize(void)
|
|
{
|
|
/* Start for Constant: '<S5>/Constant' */
|
|
CANTest_B.Ready = CANTest_P.Constant_Value;
|
|
|
|
/* Start for Constant: '<S5>/Constant1' */
|
|
CANTest_B.Gear = CANTest_P.Constant1_Value;
|
|
|
|
/* Start for Constant: '<S5>/Constant2' */
|
|
CANTest_B.BMS = CANTest_P.Constant2_Value;
|
|
|
|
/* Start for Constant: '<S5>/Constant3' */
|
|
CANTest_B.PosTQLim = CANTest_P.Constant3_Value;
|
|
|
|
/* Start for Constant: '<S5>/Constant4' */
|
|
CANTest_B.NegTQLim = CANTest_P.Constant4_Value;
|
|
|
|
/* Start for S-Function (sg_IO61X_write_s): '<S5>/CAN Write1' */
|
|
/* Level2 S-Function Block: '<S5>/CAN Write1' (sg_IO61X_write_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[2];
|
|
sfcnStart(rts);
|
|
if (ssGetErrorStatus(rts) != (NULL))
|
|
return;
|
|
}
|
|
|
|
/* Start for Iterator SubSystem: '<Root>/DAQ_In' */
|
|
|
|
/* Start for S-Function (sg_IO613_setup_s): '<S1>/CAN Setup' */
|
|
/* Level2 S-Function Block: '<S1>/CAN Setup' (sg_IO613_setup_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[0];
|
|
sfcnStart(rts);
|
|
if (ssGetErrorStatus(rts) != (NULL))
|
|
return;
|
|
}
|
|
|
|
/* Start for S-Function (sg_IO61X_read_s): '<S1>/CAN Read1' */
|
|
/* Level2 S-Function Block: '<S1>/CAN Read1' (sg_IO61X_read_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[1];
|
|
sfcnStart(rts);
|
|
if (ssGetErrorStatus(rts) != (NULL))
|
|
return;
|
|
}
|
|
|
|
/* Start for S-Function (scanunpack): '<S1>/CAN Unpack2' */
|
|
|
|
/*-----------S-Function Block: <S1>/CAN Unpack2 -----------------*/
|
|
|
|
/* End of Start for SubSystem: '<Root>/DAQ_In' */
|
|
|
|
/* InitializeConditions for UnitDelay: '<S6>/d1' */
|
|
CANTest_DW.d1_DSTATE = CANTest_P.d1_InitialCondition;
|
|
|
|
/* InitializeConditions for UnitDelay: '<S6>/d' */
|
|
CANTest_DW.d_DSTATE = CANTest_P.d_InitialCondition;
|
|
}
|
|
|
|
/* Model terminate function */
|
|
static void CANTest_terminate(void)
|
|
{
|
|
/* Terminate for S-Function (sg_IO61X_write_s): '<S5>/CAN Write1' */
|
|
/* Level2 S-Function Block: '<S5>/CAN Write1' (sg_IO61X_write_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[2];
|
|
sfcnTerminate(rts);
|
|
}
|
|
|
|
/* Terminate for Iterator SubSystem: '<Root>/DAQ_In' */
|
|
|
|
/* Terminate for S-Function (sg_IO613_setup_s): '<S1>/CAN Setup' */
|
|
/* Level2 S-Function Block: '<S1>/CAN Setup' (sg_IO613_setup_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[0];
|
|
sfcnTerminate(rts);
|
|
}
|
|
|
|
/* Terminate for S-Function (sg_IO61X_read_s): '<S1>/CAN Read1' */
|
|
/* Level2 S-Function Block: '<S1>/CAN Read1' (sg_IO61X_read_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[1];
|
|
sfcnTerminate(rts);
|
|
}
|
|
|
|
/* End of Terminate for SubSystem: '<Root>/DAQ_In' */
|
|
}
|
|
|
|
/*========================================================================*
|
|
* Start of Classic call interface *
|
|
*========================================================================*/
|
|
void MdlOutputs(int_T tid)
|
|
{
|
|
CANTest_output();
|
|
UNUSED_PARAMETER(tid);
|
|
}
|
|
|
|
void MdlUpdate(int_T tid)
|
|
{
|
|
CANTest_update();
|
|
UNUSED_PARAMETER(tid);
|
|
}
|
|
|
|
void MdlInitializeSizes(void)
|
|
{
|
|
}
|
|
|
|
void MdlInitializeSampleTimes(void)
|
|
{
|
|
}
|
|
|
|
void MdlInitialize(void)
|
|
{
|
|
}
|
|
|
|
void MdlStart(void)
|
|
{
|
|
CANTest_initialize();
|
|
}
|
|
|
|
void MdlTerminate(void)
|
|
{
|
|
CANTest_terminate();
|
|
}
|
|
|
|
/* Registration function */
|
|
RT_MODEL_CANTest_T *CANTest(void)
|
|
{
|
|
/* Registration code */
|
|
|
|
/* initialize non-finites */
|
|
rt_InitInfAndNaN(sizeof(real_T));
|
|
|
|
/* initialize real-time model */
|
|
(void) memset((void *)CANTest_M, 0,
|
|
sizeof(RT_MODEL_CANTest_T));
|
|
rtsiSetSolverName(&CANTest_M->solverInfo,"FixedStepDiscrete");
|
|
CANTest_M->solverInfoPtr = (&CANTest_M->solverInfo);
|
|
|
|
/* Initialize timing info */
|
|
{
|
|
int_T *mdlTsMap = CANTest_M->Timing.sampleTimeTaskIDArray;
|
|
mdlTsMap[0] = 0;
|
|
CANTest_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
|
|
CANTest_M->Timing.sampleTimes = (&CANTest_M->Timing.sampleTimesArray[0]);
|
|
CANTest_M->Timing.offsetTimes = (&CANTest_M->Timing.offsetTimesArray[0]);
|
|
|
|
/* task periods */
|
|
CANTest_M->Timing.sampleTimes[0] = (0.002);
|
|
|
|
/* task offsets */
|
|
CANTest_M->Timing.offsetTimes[0] = (0.0);
|
|
}
|
|
|
|
rtmSetTPtr(CANTest_M, &CANTest_M->Timing.tArray[0]);
|
|
|
|
{
|
|
int_T *mdlSampleHits = CANTest_M->Timing.sampleHitArray;
|
|
mdlSampleHits[0] = 1;
|
|
CANTest_M->Timing.sampleHits = (&mdlSampleHits[0]);
|
|
}
|
|
|
|
rtmSetTFinal(CANTest_M, -1);
|
|
CANTest_M->Timing.stepSize0 = 0.002;
|
|
|
|
/* Setup for data logging */
|
|
{
|
|
static RTWLogInfo rt_DataLoggingInfo;
|
|
rt_DataLoggingInfo.loggingInterval = NULL;
|
|
CANTest_M->rtwLogInfo = &rt_DataLoggingInfo;
|
|
}
|
|
|
|
/* Setup for data logging */
|
|
{
|
|
/*
|
|
* Set pointers to the data and signal info each state
|
|
*/
|
|
{
|
|
static int_T rt_LoggedStateWidths[] = {
|
|
1,
|
|
1
|
|
};
|
|
|
|
static int_T rt_LoggedStateNumDimensions[] = {
|
|
1,
|
|
1
|
|
};
|
|
|
|
static int_T rt_LoggedStateDimensions[] = {
|
|
1,
|
|
1
|
|
};
|
|
|
|
static boolean_T rt_LoggedStateIsVarDims[] = {
|
|
0,
|
|
0
|
|
};
|
|
|
|
static BuiltInDTypeId rt_LoggedStateDataTypeIds[] = {
|
|
SS_DOUBLE,
|
|
SS_DOUBLE
|
|
};
|
|
|
|
static int_T rt_LoggedStateComplexSignals[] = {
|
|
0,
|
|
0
|
|
};
|
|
|
|
static RTWPreprocessingFcnPtr rt_LoggingStatePreprocessingFcnPtrs[] = {
|
|
(NULL),
|
|
(NULL)
|
|
};
|
|
|
|
static const char_T *rt_LoggedStateLabels[] = {
|
|
"DSTATE",
|
|
"DSTATE"
|
|
};
|
|
|
|
static const char_T *rt_LoggedStateBlockNames[] = {
|
|
"CANTest/Mon_Cont/LPFM/d1",
|
|
"CANTest/Mon_Cont/LPFM/d"
|
|
};
|
|
|
|
static const char_T *rt_LoggedStateNames[] = {
|
|
"",
|
|
""
|
|
};
|
|
|
|
static boolean_T rt_LoggedStateCrossMdlRef[] = {
|
|
0,
|
|
0
|
|
};
|
|
|
|
static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
|
|
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 },
|
|
|
|
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 }
|
|
};
|
|
|
|
static RTWLogSignalInfo rt_LoggedStateSignalInfo = {
|
|
2,
|
|
rt_LoggedStateWidths,
|
|
rt_LoggedStateNumDimensions,
|
|
rt_LoggedStateDimensions,
|
|
rt_LoggedStateIsVarDims,
|
|
(NULL),
|
|
(NULL),
|
|
rt_LoggedStateDataTypeIds,
|
|
rt_LoggedStateComplexSignals,
|
|
(NULL),
|
|
rt_LoggingStatePreprocessingFcnPtrs,
|
|
|
|
{ rt_LoggedStateLabels },
|
|
(NULL),
|
|
(NULL),
|
|
(NULL),
|
|
|
|
{ rt_LoggedStateBlockNames },
|
|
|
|
{ rt_LoggedStateNames },
|
|
rt_LoggedStateCrossMdlRef,
|
|
rt_RTWLogDataTypeConvert
|
|
};
|
|
|
|
static void * rt_LoggedStateSignalPtrs[2];
|
|
rtliSetLogXSignalPtrs(CANTest_M->rtwLogInfo, (LogSignalPtrsType)
|
|
rt_LoggedStateSignalPtrs);
|
|
rtliSetLogXSignalInfo(CANTest_M->rtwLogInfo, &rt_LoggedStateSignalInfo);
|
|
rt_LoggedStateSignalPtrs[0] = (void*)&CANTest_DW.d1_DSTATE;
|
|
rt_LoggedStateSignalPtrs[1] = (void*)&CANTest_DW.d_DSTATE;
|
|
}
|
|
|
|
rtliSetLogT(CANTest_M->rtwLogInfo, "tout");
|
|
rtliSetLogX(CANTest_M->rtwLogInfo, "xout");
|
|
rtliSetLogXFinal(CANTest_M->rtwLogInfo, "");
|
|
rtliSetLogVarNameModifier(CANTest_M->rtwLogInfo, "rt_");
|
|
rtliSetLogFormat(CANTest_M->rtwLogInfo, 2);
|
|
rtliSetLogMaxRows(CANTest_M->rtwLogInfo, 0);
|
|
rtliSetLogDecimation(CANTest_M->rtwLogInfo, 1);
|
|
rtliSetLogY(CANTest_M->rtwLogInfo, "");
|
|
rtliSetLogYSignalInfo(CANTest_M->rtwLogInfo, (NULL));
|
|
rtliSetLogYSignalPtrs(CANTest_M->rtwLogInfo, (NULL));
|
|
}
|
|
|
|
CANTest_M->solverInfoPtr = (&CANTest_M->solverInfo);
|
|
CANTest_M->Timing.stepSize = (0.002);
|
|
rtsiSetFixedStepSize(&CANTest_M->solverInfo, 0.002);
|
|
rtsiSetSolverMode(&CANTest_M->solverInfo, SOLVER_MODE_SINGLETASKING);
|
|
|
|
/* block I/O */
|
|
CANTest_M->blockIO = ((void *) &CANTest_B);
|
|
(void) memset(((void *) &CANTest_B), 0,
|
|
sizeof(B_CANTest_T));
|
|
|
|
{
|
|
CANTest_B.CANPack = CAN_DATATYPE_GROUND;
|
|
CANTest_B.CANRead1_o2 = CAN_DATATYPE_GROUND;
|
|
CANTest_B.ContMode = 0.0;
|
|
CANTest_B.Ready = 0.0;
|
|
CANTest_B.Gear = 0.0;
|
|
CANTest_B.BMS = 0.0;
|
|
CANTest_B.PosTQLim = 0.0;
|
|
CANTest_B.NegTQLim = 0.0;
|
|
CANTest_B.d1 = 0.0;
|
|
CANTest_B.Sum3 = 0.0;
|
|
CANTest_B.gain = 0.0;
|
|
CANTest_B.gain2 = 0.0;
|
|
CANTest_B.Product2 = 0.0;
|
|
CANTest_B.gain1 = 0.0;
|
|
CANTest_B.Sum1 = 0.0;
|
|
CANTest_B.d = 0.0;
|
|
CANTest_B.Product11 = 0.0;
|
|
CANTest_B.Sum2 = 0.0;
|
|
CANTest_B.Sum4 = 0.0;
|
|
CANTest_B.Product1 = 0.0;
|
|
CANTest_B.RPM = 0.0;
|
|
CANTest_B.TQ = 0.0;
|
|
}
|
|
|
|
/* parameters */
|
|
CANTest_M->defaultParam = ((real_T *)&CANTest_P);
|
|
|
|
/* states (dwork) */
|
|
CANTest_M->dwork = ((void *) &CANTest_DW);
|
|
(void) memset((void *)&CANTest_DW, 0,
|
|
sizeof(DW_CANTest_T));
|
|
CANTest_DW.d1_DSTATE = 0.0;
|
|
CANTest_DW.d_DSTATE = 0.0;
|
|
|
|
/* Initialize DataMapInfo substructure containing ModelMap for C API */
|
|
CANTest_InitializeDataMapInfo();
|
|
|
|
/* child S-Function registration */
|
|
{
|
|
RTWSfcnInfo *sfcnInfo = &CANTest_M->NonInlinedSFcns.sfcnInfo;
|
|
CANTest_M->sfcnInfo = (sfcnInfo);
|
|
rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(CANTest_M)));
|
|
rtssSetNumRootSampTimesPtr(sfcnInfo, &CANTest_M->Sizes.numSampTimes);
|
|
CANTest_M->NonInlinedSFcns.taskTimePtrs[0] = &(rtmGetTPtr(CANTest_M)[0]);
|
|
rtssSetTPtrPtr(sfcnInfo,CANTest_M->NonInlinedSFcns.taskTimePtrs);
|
|
rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(CANTest_M));
|
|
rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(CANTest_M));
|
|
rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(CANTest_M));
|
|
rtssSetStepSizePtr(sfcnInfo, &CANTest_M->Timing.stepSize);
|
|
rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(CANTest_M));
|
|
rtssSetDerivCacheNeedsResetPtr(sfcnInfo, &CANTest_M->derivCacheNeedsReset);
|
|
rtssSetZCCacheNeedsResetPtr(sfcnInfo, &CANTest_M->zCCacheNeedsReset);
|
|
rtssSetContTimeOutputInconsistentWithStateAtMajorStepPtr(sfcnInfo,
|
|
&CANTest_M->CTOutputIncnstWithState);
|
|
rtssSetSampleHitsPtr(sfcnInfo, &CANTest_M->Timing.sampleHits);
|
|
rtssSetPerTaskSampleHitsPtr(sfcnInfo, &CANTest_M->Timing.perTaskSampleHits);
|
|
rtssSetSimModePtr(sfcnInfo, &CANTest_M->simMode);
|
|
rtssSetSolverInfoPtr(sfcnInfo, &CANTest_M->solverInfoPtr);
|
|
}
|
|
|
|
CANTest_M->Sizes.numSFcns = (3);
|
|
|
|
/* register each child */
|
|
{
|
|
(void) memset((void *)&CANTest_M->NonInlinedSFcns.childSFunctions[0], 0,
|
|
3*sizeof(SimStruct));
|
|
CANTest_M->childSfunctions = (&CANTest_M->
|
|
NonInlinedSFcns.childSFunctionPtrs[0]);
|
|
CANTest_M->childSfunctions[0] = (&CANTest_M->
|
|
NonInlinedSFcns.childSFunctions[0]);
|
|
CANTest_M->childSfunctions[1] = (&CANTest_M->
|
|
NonInlinedSFcns.childSFunctions[1]);
|
|
CANTest_M->childSfunctions[2] = (&CANTest_M->
|
|
NonInlinedSFcns.childSFunctions[2]);
|
|
|
|
/* Level2 S-Function Block: CANTest/<S1>/CAN Setup (sg_IO613_setup_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[0];
|
|
|
|
/* timing info */
|
|
time_T *sfcnPeriod = CANTest_M->NonInlinedSFcns.Sfcn0.sfcnPeriod;
|
|
time_T *sfcnOffset = CANTest_M->NonInlinedSFcns.Sfcn0.sfcnOffset;
|
|
int_T *sfcnTsMap = CANTest_M->NonInlinedSFcns.Sfcn0.sfcnTsMap;
|
|
(void) memset((void*)sfcnPeriod, 0,
|
|
sizeof(time_T)*1);
|
|
(void) memset((void*)sfcnOffset, 0,
|
|
sizeof(time_T)*1);
|
|
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
|
|
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
|
|
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
|
|
|
|
{
|
|
ssSetBlkInfo2Ptr(rts, &CANTest_M->NonInlinedSFcns.blkInfo2[0]);
|
|
}
|
|
|
|
_ssSetBlkInfo2PortInfo2Ptr(rts,
|
|
&CANTest_M->NonInlinedSFcns.inputOutputPortInfo2[0]);
|
|
|
|
/* Set up the mdlInfo pointer */
|
|
ssSetRTWSfcnInfo(rts, CANTest_M->sfcnInfo);
|
|
|
|
/* Allocate memory of model methods 2 */
|
|
{
|
|
ssSetModelMethods2(rts, &CANTest_M->NonInlinedSFcns.methods2[0]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 3 */
|
|
{
|
|
ssSetModelMethods3(rts, &CANTest_M->NonInlinedSFcns.methods3[0]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 4 */
|
|
{
|
|
ssSetModelMethods4(rts, &CANTest_M->NonInlinedSFcns.methods4[0]);
|
|
}
|
|
|
|
/* Allocate memory for states auxilliary information */
|
|
{
|
|
ssSetStatesInfo2(rts, &CANTest_M->NonInlinedSFcns.statesInfo2[0]);
|
|
ssSetPeriodicStatesInfo(rts,
|
|
&CANTest_M->NonInlinedSFcns.periodicStatesInfo[0]);
|
|
}
|
|
|
|
/* path info */
|
|
ssSetModelName(rts, "CAN Setup");
|
|
ssSetPath(rts, "CANTest/DAQ_In/CAN Setup");
|
|
ssSetRTModel(rts,CANTest_M);
|
|
ssSetParentSS(rts, (NULL));
|
|
ssSetRootSS(rts, rts);
|
|
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
|
|
|
|
/* parameters */
|
|
{
|
|
mxArray **sfcnParams = (mxArray **)
|
|
&CANTest_M->NonInlinedSFcns.Sfcn0.params;
|
|
ssSetSFcnParamsCount(rts, 24);
|
|
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
|
|
ssSetSFcnParam(rts, 0, (mxArray*)CANTest_P.CANSetup_P1_Size);
|
|
ssSetSFcnParam(rts, 1, (mxArray*)CANTest_P.CANSetup_P2_Size);
|
|
ssSetSFcnParam(rts, 2, (mxArray*)CANTest_P.CANSetup_P3_Size);
|
|
ssSetSFcnParam(rts, 3, (mxArray*)CANTest_P.CANSetup_P4_Size);
|
|
ssSetSFcnParam(rts, 4, (mxArray*)CANTest_P.CANSetup_P5_Size);
|
|
ssSetSFcnParam(rts, 5, (mxArray*)CANTest_P.CANSetup_P6_Size);
|
|
ssSetSFcnParam(rts, 6, (mxArray*)CANTest_P.CANSetup_P7_Size);
|
|
ssSetSFcnParam(rts, 7, (mxArray*)CANTest_P.CANSetup_P8_Size);
|
|
ssSetSFcnParam(rts, 8, (mxArray*)CANTest_P.CANSetup_P9_Size);
|
|
ssSetSFcnParam(rts, 9, (mxArray*)CANTest_P.CANSetup_P10_Size);
|
|
ssSetSFcnParam(rts, 10, (mxArray*)CANTest_P.CANSetup_P11_Size);
|
|
ssSetSFcnParam(rts, 11, (mxArray*)CANTest_P.CANSetup_P12_Size);
|
|
ssSetSFcnParam(rts, 12, (mxArray*)CANTest_P.CANSetup_P13_Size);
|
|
ssSetSFcnParam(rts, 13, (mxArray*)CANTest_P.CANSetup_P14_Size);
|
|
ssSetSFcnParam(rts, 14, (mxArray*)CANTest_P.CANSetup_P15_Size);
|
|
ssSetSFcnParam(rts, 15, (mxArray*)CANTest_P.CANSetup_P16_Size);
|
|
ssSetSFcnParam(rts, 16, (mxArray*)CANTest_P.CANSetup_P17_Size);
|
|
ssSetSFcnParam(rts, 17, (mxArray*)CANTest_P.CANSetup_P18_Size);
|
|
ssSetSFcnParam(rts, 18, (mxArray*)CANTest_P.CANSetup_P19_Size);
|
|
ssSetSFcnParam(rts, 19, (mxArray*)CANTest_P.CANSetup_P20_Size);
|
|
ssSetSFcnParam(rts, 20, (mxArray*)CANTest_P.CANSetup_P21_Size);
|
|
ssSetSFcnParam(rts, 21, (mxArray*)CANTest_P.CANSetup_P22_Size);
|
|
ssSetSFcnParam(rts, 22, (mxArray*)CANTest_P.CANSetup_P23_Size);
|
|
ssSetSFcnParam(rts, 23, (mxArray*)CANTest_P.CANSetup_P24_Size);
|
|
}
|
|
|
|
/* work vectors */
|
|
ssSetIWork(rts, (int_T *) &CANTest_DW.CANSetup_IWORK);
|
|
|
|
{
|
|
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
|
|
&CANTest_M->NonInlinedSFcns.Sfcn0.dWork;
|
|
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
|
|
&CANTest_M->NonInlinedSFcns.Sfcn0.dWorkAux;
|
|
ssSetSFcnDWork(rts, dWorkRecord);
|
|
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
|
|
_ssSetNumDWork(rts, 1);
|
|
|
|
/* IWORK */
|
|
ssSetDWorkWidth(rts, 0, 1);
|
|
ssSetDWorkDataType(rts, 0,SS_INTEGER);
|
|
ssSetDWorkComplexSignal(rts, 0, 0);
|
|
ssSetDWork(rts, 0, &CANTest_DW.CANSetup_IWORK);
|
|
}
|
|
|
|
/* registration */
|
|
sg_IO613_setup_s(rts);
|
|
sfcnInitializeSizes(rts);
|
|
sfcnInitializeSampleTimes(rts);
|
|
|
|
/* adjust sample time */
|
|
ssSetSampleTime(rts, 0, 0.002);
|
|
ssSetOffsetTime(rts, 0, 0.0);
|
|
sfcnTsMap[0] = 0;
|
|
|
|
/* set compiled values of dynamic vector attributes */
|
|
ssSetNumNonsampledZCs(rts, 0);
|
|
|
|
/* Update connectivity flags for each port */
|
|
/* Update the BufferDstPort flags for each input port */
|
|
}
|
|
|
|
/* Level2 S-Function Block: CANTest/<S1>/CAN Read1 (sg_IO61X_read_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[1];
|
|
|
|
/* timing info */
|
|
time_T *sfcnPeriod = CANTest_M->NonInlinedSFcns.Sfcn1.sfcnPeriod;
|
|
time_T *sfcnOffset = CANTest_M->NonInlinedSFcns.Sfcn1.sfcnOffset;
|
|
int_T *sfcnTsMap = CANTest_M->NonInlinedSFcns.Sfcn1.sfcnTsMap;
|
|
(void) memset((void*)sfcnPeriod, 0,
|
|
sizeof(time_T)*1);
|
|
(void) memset((void*)sfcnOffset, 0,
|
|
sizeof(time_T)*1);
|
|
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
|
|
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
|
|
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
|
|
|
|
{
|
|
ssSetBlkInfo2Ptr(rts, &CANTest_M->NonInlinedSFcns.blkInfo2[1]);
|
|
}
|
|
|
|
_ssSetBlkInfo2PortInfo2Ptr(rts,
|
|
&CANTest_M->NonInlinedSFcns.inputOutputPortInfo2[1]);
|
|
|
|
/* Set up the mdlInfo pointer */
|
|
ssSetRTWSfcnInfo(rts, CANTest_M->sfcnInfo);
|
|
|
|
/* Allocate memory of model methods 2 */
|
|
{
|
|
ssSetModelMethods2(rts, &CANTest_M->NonInlinedSFcns.methods2[1]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 3 */
|
|
{
|
|
ssSetModelMethods3(rts, &CANTest_M->NonInlinedSFcns.methods3[1]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 4 */
|
|
{
|
|
ssSetModelMethods4(rts, &CANTest_M->NonInlinedSFcns.methods4[1]);
|
|
}
|
|
|
|
/* Allocate memory for states auxilliary information */
|
|
{
|
|
ssSetStatesInfo2(rts, &CANTest_M->NonInlinedSFcns.statesInfo2[1]);
|
|
ssSetPeriodicStatesInfo(rts,
|
|
&CANTest_M->NonInlinedSFcns.periodicStatesInfo[1]);
|
|
}
|
|
|
|
/* outputs */
|
|
{
|
|
ssSetPortInfoForOutputs(rts,
|
|
&CANTest_M->NonInlinedSFcns.Sfcn1.outputPortInfo[0]);
|
|
_ssSetNumOutputPorts(rts, 2);
|
|
_ssSetPortInfo2ForOutputUnits(rts,
|
|
&CANTest_M->NonInlinedSFcns.Sfcn1.outputPortUnits[0]);
|
|
ssSetOutputPortUnit(rts, 0, 0);
|
|
ssSetOutputPortUnit(rts, 1, 0);
|
|
_ssSetPortInfo2ForOutputCoSimAttribute(rts,
|
|
&CANTest_M->NonInlinedSFcns.Sfcn1.outputPortCoSimAttribute[0]);
|
|
ssSetOutputPortIsContinuousQuantity(rts, 0, 0);
|
|
ssSetOutputPortIsContinuousQuantity(rts, 1, 0);
|
|
|
|
/* port 0 */
|
|
{
|
|
_ssSetOutputPortNumDimensions(rts, 0, 1);
|
|
ssSetOutputPortWidth(rts, 0, 1);
|
|
ssSetOutputPortSignal(rts, 0, ((boolean_T *) &CANTest_B.CANRead1_o1));
|
|
}
|
|
|
|
/* port 1 */
|
|
{
|
|
_ssSetOutputPortNumDimensions(rts, 1, 1);
|
|
ssSetOutputPortWidth(rts, 1, 1);
|
|
ssSetOutputPortSignal(rts, 1, ((CAN_DATATYPE *) &CANTest_B.CANRead1_o2));
|
|
}
|
|
}
|
|
|
|
/* path info */
|
|
ssSetModelName(rts, "CAN Read1");
|
|
ssSetPath(rts, "CANTest/DAQ_In/CAN Read1");
|
|
ssSetRTModel(rts,CANTest_M);
|
|
ssSetParentSS(rts, (NULL));
|
|
ssSetRootSS(rts, rts);
|
|
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
|
|
|
|
/* parameters */
|
|
{
|
|
mxArray **sfcnParams = (mxArray **)
|
|
&CANTest_M->NonInlinedSFcns.Sfcn1.params;
|
|
ssSetSFcnParamsCount(rts, 6);
|
|
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
|
|
ssSetSFcnParam(rts, 0, (mxArray*)CANTest_P.CANRead1_P1_Size);
|
|
ssSetSFcnParam(rts, 1, (mxArray*)CANTest_P.CANRead1_P2_Size);
|
|
ssSetSFcnParam(rts, 2, (mxArray*)CANTest_P.CANRead1_P3_Size);
|
|
ssSetSFcnParam(rts, 3, (mxArray*)CANTest_P.CANRead1_P4_Size);
|
|
ssSetSFcnParam(rts, 4, (mxArray*)CANTest_P.CANRead1_P5_Size);
|
|
ssSetSFcnParam(rts, 5, (mxArray*)CANTest_P.CANRead1_P6_Size);
|
|
}
|
|
|
|
/* work vectors */
|
|
ssSetIWork(rts, (int_T *) &CANTest_DW.CANRead1_IWORK);
|
|
|
|
{
|
|
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
|
|
&CANTest_M->NonInlinedSFcns.Sfcn1.dWork;
|
|
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
|
|
&CANTest_M->NonInlinedSFcns.Sfcn1.dWorkAux;
|
|
ssSetSFcnDWork(rts, dWorkRecord);
|
|
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
|
|
_ssSetNumDWork(rts, 1);
|
|
|
|
/* IWORK */
|
|
ssSetDWorkWidth(rts, 0, 1);
|
|
ssSetDWorkDataType(rts, 0,SS_INTEGER);
|
|
ssSetDWorkComplexSignal(rts, 0, 0);
|
|
ssSetDWork(rts, 0, &CANTest_DW.CANRead1_IWORK);
|
|
}
|
|
|
|
/* registration */
|
|
sg_IO61X_read_s(rts);
|
|
sfcnInitializeSizes(rts);
|
|
sfcnInitializeSampleTimes(rts);
|
|
|
|
/* adjust sample time */
|
|
ssSetSampleTime(rts, 0, 0.002);
|
|
ssSetOffsetTime(rts, 0, 0.0);
|
|
sfcnTsMap[0] = 0;
|
|
|
|
/* set compiled values of dynamic vector attributes */
|
|
ssSetNumNonsampledZCs(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: CANTest/<S5>/CAN Write1 (sg_IO61X_write_s) */
|
|
{
|
|
SimStruct *rts = CANTest_M->childSfunctions[2];
|
|
|
|
/* timing info */
|
|
time_T *sfcnPeriod = CANTest_M->NonInlinedSFcns.Sfcn2.sfcnPeriod;
|
|
time_T *sfcnOffset = CANTest_M->NonInlinedSFcns.Sfcn2.sfcnOffset;
|
|
int_T *sfcnTsMap = CANTest_M->NonInlinedSFcns.Sfcn2.sfcnTsMap;
|
|
(void) memset((void*)sfcnPeriod, 0,
|
|
sizeof(time_T)*1);
|
|
(void) memset((void*)sfcnOffset, 0,
|
|
sizeof(time_T)*1);
|
|
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
|
|
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
|
|
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
|
|
|
|
{
|
|
ssSetBlkInfo2Ptr(rts, &CANTest_M->NonInlinedSFcns.blkInfo2[2]);
|
|
}
|
|
|
|
_ssSetBlkInfo2PortInfo2Ptr(rts,
|
|
&CANTest_M->NonInlinedSFcns.inputOutputPortInfo2[2]);
|
|
|
|
/* Set up the mdlInfo pointer */
|
|
ssSetRTWSfcnInfo(rts, CANTest_M->sfcnInfo);
|
|
|
|
/* Allocate memory of model methods 2 */
|
|
{
|
|
ssSetModelMethods2(rts, &CANTest_M->NonInlinedSFcns.methods2[2]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 3 */
|
|
{
|
|
ssSetModelMethods3(rts, &CANTest_M->NonInlinedSFcns.methods3[2]);
|
|
}
|
|
|
|
/* Allocate memory of model methods 4 */
|
|
{
|
|
ssSetModelMethods4(rts, &CANTest_M->NonInlinedSFcns.methods4[2]);
|
|
}
|
|
|
|
/* Allocate memory for states auxilliary information */
|
|
{
|
|
ssSetStatesInfo2(rts, &CANTest_M->NonInlinedSFcns.statesInfo2[2]);
|
|
ssSetPeriodicStatesInfo(rts,
|
|
&CANTest_M->NonInlinedSFcns.periodicStatesInfo[2]);
|
|
}
|
|
|
|
/* inputs */
|
|
{
|
|
_ssSetNumInputPorts(rts, 1);
|
|
ssSetPortInfoForInputs(rts,
|
|
&CANTest_M->NonInlinedSFcns.Sfcn2.inputPortInfo[0]);
|
|
_ssSetPortInfo2ForInputUnits(rts,
|
|
&CANTest_M->NonInlinedSFcns.Sfcn2.inputPortUnits[0]);
|
|
ssSetInputPortUnit(rts, 0, 0);
|
|
_ssSetPortInfo2ForInputCoSimAttribute(rts,
|
|
&CANTest_M->NonInlinedSFcns.Sfcn2.inputPortCoSimAttribute[0]);
|
|
ssSetInputPortIsContinuousQuantity(rts, 0, 0);
|
|
|
|
/* port 0 */
|
|
{
|
|
ssSetInputPortRequiredContiguous(rts, 0, 1);
|
|
ssSetInputPortSignal(rts, 0, &CANTest_B.CANPack);
|
|
_ssSetInputPortNumDimensions(rts, 0, 1);
|
|
ssSetInputPortWidth(rts, 0, 1);
|
|
}
|
|
}
|
|
|
|
/* path info */
|
|
ssSetModelName(rts, "CAN Write1");
|
|
ssSetPath(rts, "CANTest/DAQ_Out/CANBoard/CAN Write1");
|
|
ssSetRTModel(rts,CANTest_M);
|
|
ssSetParentSS(rts, (NULL));
|
|
ssSetRootSS(rts, rts);
|
|
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
|
|
|
|
/* parameters */
|
|
{
|
|
mxArray **sfcnParams = (mxArray **)
|
|
&CANTest_M->NonInlinedSFcns.Sfcn2.params;
|
|
ssSetSFcnParamsCount(rts, 7);
|
|
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
|
|
ssSetSFcnParam(rts, 0, (mxArray*)CANTest_P.CANWrite1_P1_Size);
|
|
ssSetSFcnParam(rts, 1, (mxArray*)CANTest_P.CANWrite1_P2_Size);
|
|
ssSetSFcnParam(rts, 2, (mxArray*)CANTest_P.CANWrite1_P3_Size);
|
|
ssSetSFcnParam(rts, 3, (mxArray*)CANTest_P.CANWrite1_P4_Size);
|
|
ssSetSFcnParam(rts, 4, (mxArray*)CANTest_P.CANWrite1_P5_Size);
|
|
ssSetSFcnParam(rts, 5, (mxArray*)CANTest_P.CANWrite1_P6_Size);
|
|
ssSetSFcnParam(rts, 6, (mxArray*)CANTest_P.CANWrite1_P7_Size);
|
|
}
|
|
|
|
/* work vectors */
|
|
ssSetIWork(rts, (int_T *) &CANTest_DW.CANWrite1_IWORK);
|
|
ssSetPWork(rts, (void **) &CANTest_DW.CANWrite1_PWORK);
|
|
|
|
{
|
|
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
|
|
&CANTest_M->NonInlinedSFcns.Sfcn2.dWork;
|
|
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
|
|
&CANTest_M->NonInlinedSFcns.Sfcn2.dWorkAux;
|
|
ssSetSFcnDWork(rts, dWorkRecord);
|
|
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
|
|
_ssSetNumDWork(rts, 2);
|
|
|
|
/* IWORK */
|
|
ssSetDWorkWidth(rts, 0, 1);
|
|
ssSetDWorkDataType(rts, 0,SS_INTEGER);
|
|
ssSetDWorkComplexSignal(rts, 0, 0);
|
|
ssSetDWork(rts, 0, &CANTest_DW.CANWrite1_IWORK);
|
|
|
|
/* PWORK */
|
|
ssSetDWorkWidth(rts, 1, 1);
|
|
ssSetDWorkDataType(rts, 1,SS_POINTER);
|
|
ssSetDWorkComplexSignal(rts, 1, 0);
|
|
ssSetDWork(rts, 1, &CANTest_DW.CANWrite1_PWORK);
|
|
}
|
|
|
|
/* registration */
|
|
sg_IO61X_write_s(rts);
|
|
sfcnInitializeSizes(rts);
|
|
sfcnInitializeSampleTimes(rts);
|
|
|
|
/* adjust sample time */
|
|
ssSetSampleTime(rts, 0, 0.002);
|
|
ssSetOffsetTime(rts, 0, 0.0);
|
|
sfcnTsMap[0] = 0;
|
|
|
|
/* set compiled values of dynamic vector attributes */
|
|
ssSetNumNonsampledZCs(rts, 0);
|
|
|
|
/* Update connectivity flags for each port */
|
|
_ssSetInputPortConnected(rts, 0, 1);
|
|
|
|
/* Update the BufferDstPort flags for each input port */
|
|
ssSetInputPortBufferDstPort(rts, 0, -1);
|
|
}
|
|
}
|
|
|
|
/* Initialize Sizes */
|
|
CANTest_M->Sizes.numContStates = (0);/* Number of continuous states */
|
|
CANTest_M->Sizes.numY = (0); /* Number of model outputs */
|
|
CANTest_M->Sizes.numU = (0); /* Number of model inputs */
|
|
CANTest_M->Sizes.sysDirFeedThru = (0);/* The model is not direct feedthrough */
|
|
CANTest_M->Sizes.numSampTimes = (1); /* Number of sample times */
|
|
CANTest_M->Sizes.numBlocks = (39); /* Number of blocks */
|
|
CANTest_M->Sizes.numBlockIO = (23); /* Number of block outputs */
|
|
CANTest_M->Sizes.numBlockPrms = (163);/* Sum of parameter "widths" */
|
|
return CANTest_M;
|
|
}
|
|
|
|
/*========================================================================*
|
|
* End of Classic call interface *
|
|
*========================================================================*/
|