Model Based Design/Development of Tilt and Telescopic Steering Column ADAS feature and Perform MIL and SIL testing using Matlab-Simulink

 

 

                                                     Introduction to Model-Based Development/Design(MBD)

 

MBD is a combination of modelling, simulation and validation. It is not nearly developing a model for code generation, it is about understanding the requirements of design and develop a model. The design can be validated provided by Matlab which has the competency to analyse a requirement. The user needs to ensure that the complete requirement needs to be converted onto a model in order to avoid errors. Simulation, on the other hand, is all about testing the behaviour of the model with respect to real-time conditions. Validation is about at every stage of modelling and simulation the results acquired are error-free and of good quality level. 

 When the user is manually trying to write code, testing at the vehicle it is not possible to perform intermediate tests and checks in this process. But when it comes to the Model-based development/design approach it is possible to validate and design at the model level and convert that model into code. Again the converted code is tested on a simulation environment. Once it goes through different kinds of checks the final software can be rolled out. It is also possible to fix all kinds of errors and further modifications in the design are also possible. The Model-based development approach is continuous and Iterative. 

 

 

                                                               V - Model Software Development Life Cycle

 The different stages that are involved in developing software are called software development life cycle. As far as the Automotive industry is concerned, ADAS, Body control module, infotainment systems, powertrain software development the most commonly adopted strategy is "V model" software development cycle. In this cycle through analysis of different stages that are involved in the life cycle right from getting requirements from the customer. In order to develop a model from the requirement to the final validation process, it is necessary to check every time whether the desired outputs are being received or not. After this process, the designed model is converted to a code format. The generated code can be validated in the MATLAB-Simulink environment. After this process, the generated model/code goes into hardware in loop testing where the prototype of the vehicle is itself tested. Software is sent to the ECU (Electronic control unit). This will give the final results of real-time usage. The final process will be to roll out this to the end customer. 

Simulink (.slx files) : 

Simulink is a visual programming user interface that is designed to model a physical system. It offers a way to solve equations numerically using a graphical interface rather than programming/coding. Models contain blocks, signals and annotations in the background. 

`->` Blocks are mathematical functions that can have a varying number of Inputs and Outputs.

`->` Signals are the lines connecting varying blocks in order to help in transferring data between them. 

`->` Annotations are the text messages written underneath or above the signals and blocks for better understanding of the problem.

 

State flow:

Stateflow is a state machine design tool which is integrated with Simulink tool. Stateflow produces Simulink blocks, fed within Simulink inputs and produces Simulink outputs. State flow blocks provide seamless integration of state machine architecture into a simple Simulink environment. State machine architecture is one of the simplest model development techniques that is used for complex problems which are difficult to execute with Simulink blocks. Matlab scripts can also be integrated inside this Stateflow blocks. Stateflow integrates three basic components

1. Hierarchial and Parallel state machines

2. Control flow diagrams

3. Truth tables

A Stateflow chart contains either state diagrams or flow charts. State flow is not as complicated as programming because it is a simpler modelling approach. Most of the commands (conditions) in state flow are in the form of words. The commands are specified in 'State action' and 'transitions'. Inputs and outputs can be defined inside the model explorer window to create relation with Simulink. 

'Exclusive OR states' are the most commonly used modes of operation in which no two exclusive OR states can ever be active or execute at the same time. This helps to implement the logic in a sequential manner.

MAAB ( MATHWORKS AUTOMOTIVE ADVISORY BOARD) regulations are needed to be followed while designing state flow and modelling in Simulink to avoid errors in the code generation process.

 

Data Dictionary (.sldd file): Data dictionary is collective storage of Simulink parameters and Simulink calibration values including its attributes (variables, dimensions, min-max values, Ram file and Rom file etc). The data dictionary is linked with the model so that all the values will be assigned automatically. To make the model's data accessible, the data has to be made available using a .sldd file. Data dictionary helps to store configuration parameters, Allows for traceability from a data object to Simulink selection. 

Certain data types are established as aliases to the base data types so that this alias data types can be used in the Simulink environment for code generation. A Simulink alias is created that maps these customized data types to the base data types. The created aliases are used as part of the MBD template model. Data dictionary files can be exported and used in other models as well.

 

Requirement Analysis: Any model development / Software development starts with the requirement of the customer/client. The requirement could be a single requirement or multiple sets of requirements which needs to be implemented. These requirements could be in the form of a document. The document may use flowcharts, state machine algorithms on how to implement the problem.

A software model is built based on a clear understanding and functional implementation of the requirement specification and converting the built design model into a software code for production

Requirement traceability, on the other hand, is about tagging the requirements such that it helps whenever it is used in the further developing stage by other developers for the purpose of upgradation. 

 

Configuration Parameter Settings: Configuration parameters are some specific sets of standards/guidelines which needs to be set in order to make the model/code work in the ECU. Ideal configuration parameters are set by OEM standards or MAAB guidelines.

Important parameters that are required to set are 1. Solver information, 2. Data validity and type conversion,                  3. Connectivity and model referencing and 4. Simulation target and code generation. 

 

Model Simulation and Model Advisor Report: Model Advisor is a tool that automatically checks the models for errors, ensure the model was developed according to MAAB guidelines using predefined checks. The model advisor automatically enables the user to check for common modelling mistakes which were missed out to notice during model development. It can analyse the entire model or a subset of the model. 

The model Advisor will finally generate a report on how the checks were performed and the corresponding number of errors, warnings will be displayed. User needs to fix these errors either in Simulink environment or changing configuration parameters. 

MIL (Model in Loop) : Model in Loop is the first stage of Verification & Validation. MIL is a Testing technique where the tester tests the control model in a simulation environment. Model is developed as per requirement & once requirement is freezed, based on same requirement document, tester has to develop test vectors to test the model in a test environment. Tools like MATLAB, Reactis, BTC can be used for MIL testing.

SIL (Software in Loop) : Software in Loop Testing is second stage of Verifiation & Validation. Stage after MIL is code generation & once the model is capable of generating code, tester can perform SIL testing, where the generated code (combination of C code, H code & other supporting files) will replace the actual control model logic. Test inputs & test vectors remain the same. Tools like Simulink, BTC can be used for SIL Testing

HIL (Hardware in Loop):  Last & final stage of Verification & Validation is HIL testing. The generated C - code & H code must be converted into machine understandable Hex file & flashed into an ECU. Dedicated laboratory setup is needed to perform HIL validation. Companies like dspace, ETAS, National Instruments do dediated HIL validation

 

 

                                                               Introduction to ADAS and Levels of Autonomous Vehicles

 

 `->` ADAS stands for Advanced Driver Assistance System. It is basically an electronic system that helps the driver                   while driving or during parking operations.

`->` The safety features are designed to avoid collisions and accidents by offering technologies that alert the driver               from  doing mistakes by implementing safeguards and taking control of the vehicle. 

 `->` Adaptive cruise control, Autonomous Emergency braking, Blind spot detection, Tilt and Telescopic Steering                      column, Forward / Rearward collision warning system, Intelligent parking assistance, cross-traffic alert, etc.

 

Levels of Autonomous driving:

Autonomous driving levels vary from Level zero up to Level Five. Level 5 is an advanced stage of Autonomous driving which drives/parks the vehicle without the intervention of human

 `->`  Level 0 - No intervention of ADAS systems or electronic systems 

`->`   Level 1 - Human intervention and ADAS features work based on sensor inputs

`->`   Level 2 - Human intervention is necessary if required

`->`   Level 3 - Human intervention only in emergency situations

`->`   Level 4 - Eliminates the intervention of Driver

`->`   Level 5 - Vehicle can drive by itself 

 

• Data exchange between various ADAS features in a common platform is necessary for the effective functioning of the vehicles. Common ADAS features used in level 1 and level 2 autonomous vehicles are
• Tyre pressure monitoring systems, Adaptive cruise control, Anti-lock braking system, parking assistance system, Tilt and Telescopic steering column, Electronic stability system, Traffic sign recognition system, etc.
• Image sensors, Ultrasonic sensors, RADAR, LIDAR, Infrared are usually used in ADAS. 

 

                                                   Tilt and Telescopic Steering Column ADAS feature

 

 This Adas feature is widely used in modern automobiles which helps to adjust the steering wheel before the driver starts driving. The driver can adjust according to his/her comfort level. This feature also gives enough space for the driver which helps in entry/exit from the vehicle. Modern vehicles use an electronic switch in order to adjust the steering column to move UP, DOWN, FRONT and BACK. This adjustment should not affect the driver from seeing the instrument panel, warning lights, gauges and the infotainment system. The driver should not use this feature while driving. It may lead to losing control over the steering and could lead to accidents/injuries.

 

                                                                          Function Diagram

 

 

 

 

 Tilt and Telescopic switch is the mechanical switch which the user gives his inputs for adjustment. The physical switch should be flexible to move in all four directions. Wiring harness connects the switch with ECU in order to transfer input signals.

Switch input is the interface at model level to identify the status (present exact position) whether it is pressed, unpressed or struck condition. Based on the status of the switch the signals are sent to 'Control Algorithm' to perform its action. This algorithm detects the user input and switch position and then sends signals to the 'CAN bus to perform actions according to the user inputs. 

The power Tilt/Telescopic switch handler is responsible for Tilt/Tele switch input and performs:

• Switch contact Debounce
• Determining the state of four-dimensional switch: Tilt-Up, Tilt-Down, Telescopic forward and Telescopic Rearward.
• Transmission of CAN signals
• Detection of wake up input Activation (ignored for now)
• Diagnostic monitoring o switch input (ignored for now)

 

                                                 Requirement analysis of Tilt and Telescopic Steering column Adas  Feature:

 

Industry-standard Requirement Document:

 Requirement document varies from company to company. It could be in the form of an excel sheet/drawings (jpeg, png)/PDF. 

 Requirement conditions to develop a Model

 

 

 

 

 

 

 

 

 

 

 

 

  

 

 

 

 

 

 

•  Feature owner gives the requirement that has to be developed
• Every individual part of software/hardware will have part numbers. Usually, ECU (for ADAS) is a part member
• Tilt and telescopic feature should be enabled only if the 'ignition status' is run available at the CAN Bus. At wake up, all buttons states should be in state.
• The Tilt and Telescopic feature must reach its neutral position after the start of ignition. Later the driver can adjust according to his comfort.
• The battery voltage should be within the range of 10 to 20 volts. Minimum 10 volts and maximum 20 volts
• Once the ignition is ON then the ECU should ensure all the switches are in the unstruck position
• Struck is a hardware issue, this will block the desired signal being executed. There are chances for the execution of faulty signals during this struck position. In order to avoid these errors debounce time is being introduced. This will avoid/fix all the input errors and the actual signal will be processed.

 

                                                      Model Development of Tilt and Telescopic Function Feature

 

 The first step in the model development process is to create the in ports and out ports that are necessary for the functioning of Tilt and Telescopic feature. The inputs will be from both external (physical switch) and internal (voltage) source. Outport defines various ADAS outputs which were obtained from the given input. Here Tilt (up and Down), Tele (Forward, and Rearward) are the outputs required by the user. 

 

 A subsystem is created in Matlab 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

1	/*
2	 * File: Tilt_Telescopic_Switch.h
3	 *
4	 * Code generated for Simulink model 'Tilt_Telescopic_Switch'.
5	 *
6	 * Model version                  : 1.32
7	 * Simulink Coder version         : 8.10 (R2016a) 10-Feb-2016
8	 * C/C++ source code generated on : Mon Jul 13 10:48:09 2020
9	 *
10	 * Target selection: ert.tlc
11	 * Embedded hardware selection: Intel->x86-64 (Windows64)
12	 * Code generation objectives: Unspecified
13	 * Validation result: Not run
14	 */
15	
16	#ifndef RTW_HEADER_Tilt_Telescopic_Switch_h_
17	#define RTW_HEADER_Tilt_Telescopic_Switch_h_
18	#include 
19	#include 
20	#include 
21	#ifndef Tilt_Telescopic_Switch_COMMON_INCLUDES_
22	# define Tilt_Telescopic_Switch_COMMON_INCLUDES_
23	#include "rtwtypes.h"
24	#endif                                 /* Tilt_Telescopic_Switch_COMMON_INCLUDES_ */
25	
26	#include "Tilt_Telescopic_Switch_types.h"
27	
28	/* Includes for objects with custom storage classes. */
29	#include "Tilt_Telescopic_Switch_Function.h"
30	
31	/* Macros for accessing real-time model data structure */
32	#ifndef rtmGetErrorStatus
33	# define rtmGetErrorStatus(rtm)        ((rtm)->errorStatus)
34	#endif
35	
36	#ifndef rtmSetErrorStatus
37	# define rtmSetErrorStatus(rtm, val)   ((rtm)->errorStatus = (val))
38	#endif
39	
40	/* Block signals (auto storage) */
41	typedef struct {
42	  boolean_T Up_Switch_Output;          /* '/Tilt_Up_Debounce_Logic' */
43	  boolean_T Switch_Stuck;              /* '/Tilt_Up_Debounce_Logic' */
44	  boolean_T Rearward_Switch_Output;    /* '/Tele_Rearward_Debounce_Logic' */
45	  boolean_T Switch_Stuck_m;            /* '/Tele_Rearward_Debounce_Logic' */
46	  boolean_T Forward_Switch_Output;     /* '/Tele_Forward_Debounce_Logic' */
47	  boolean_T Switch_Stuck_l;            /* '/Tele_Forward_Debounce_Logic' */
48	  boolean_T Down_Switch_Output;        /* '/Tilt_Down_Debounce_Logic' */
49	  boolean_T Switch_Stuck_k;            /* '/Tilt_Down_Debounce_Logic' */
50	} B_Tilt_Telescopic_Switch_T;
51	
52	/* Block states (auto storage) for system '' */
53	typedef struct {
54	  uint32_T temporalCounter_i1;         /* '/Tilt_Up_Debounce_Logic' */
55	  uint32_T temporalCounter_i1_k;       /* '/Tele_Rearward_Debounce_Logic' */
56	  uint32_T temporalCounter_i1_h;       /* '/Tele_Forward_Debounce_Logic' */
57	  uint32_T temporalCounter_i1_o;       /* '/Tilt_Down_Debounce_Logic' */
58	  uint8_T is_active_c3_Tilt_Telescopic_Sw;/* '/Tilt_Up_Debounce_Logic' */
59	  uint8_T is_c3_Tilt_Telescopic_Switch;/* '/Tilt_Up_Debounce_Logic' */
60	  uint8_T is_Debounce;                 /* '/Tilt_Up_Debounce_Logic' */
61	  uint8_T is_active_c4_Tilt_Telescopic_Sw;/* '/Tele_Rearward_Debounce_Logic' */
62	  uint8_T is_c4_Tilt_Telescopic_Switch;/* '/Tele_Rearward_Debounce_Logic' */
63	  uint8_T is_Debounce_h;               /* '/Tele_Rearward_Debounce_Logic' */
64	  uint8_T is_active_c2_Tilt_Telescopic_Sw;/* '/Tele_Forward_Debounce_Logic' */
65	  uint8_T is_c2_Tilt_Telescopic_Switch;/* '/Tele_Forward_Debounce_Logic' */
66	  uint8_T is_Debounce_j;               /* '/Tele_Forward_Debounce_Logic' */
67	  uint8_T is_active_c1_Tilt_Telescopic_Sw;/* '/Tilt_Down_Debounce_Logic' */
68	  uint8_T is_c1_Tilt_Telescopic_Switch;/* '/Tilt_Down_Debounce_Logic' */
69	  uint8_T is_Debounce_e;               /* '/Tilt_Down_Debounce_Logic' */
70	  boolean_T Switch_Pos_Status_Determination;/* '/Switch_Pos_Status_Determination' */
71	} DW_Tilt_Telescopic_Switch_T;
72	
73	/* Real-time Model Data Structure */
74	struct tag_RTM_Tilt_Telescopic_Switc_T {
75	  const char_T * volatile errorStatus;
76	};
77	
78	/* Block signals (auto storage) */
79	extern B_Tilt_Telescopic_Switch_T Tilt_Telescopic_Switch_B;
80	
81	/* Block states (auto storage) */
82	extern DW_Tilt_Telescopic_Switch_T Tilt_Telescopic_Switch_DW;
83	
84	/* Model entry point functions */
85	extern void Tilt_Telescopic_Switch_initialize(void);
86	extern void Tilt_Telescopic_Switch_step0(void);
87	extern void Tilt_Telescopic_Switch_step1(void);
88	extern void Tilt_Telescopic_Switch_terminate(void);
89	
90	/* Real-time Model object */
91	extern RT_MODEL_Tilt_Telescopic_Swit_T *const Tilt_Telescopic_Switch_M;
92	
93	/*-
94	 * The generated code includes comments that allow you to trace directly
95	 * back to the appropriate location in the model.  The basic format
96	 * is /block_name, where system is the system number (uniquely
97	 * assigned by Simulink) and block_name is the name of the block.
98	 *
99	 * Use the MATLAB hilite_system command to trace the generated code back
100	 * to the model.  For example,
101	 *
102	 * hilite_system('')    - opens system 3
103	 * hilite_system('/Kp') - opens and selects block Kp which resides in S3
104	 *
105	 * Here is the system hierarchy for this model
106	 *
107	 * '' : 'Tilt_Telescopic_Switch'
108	 * ''   : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch'
109	 * ''   : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele'
110	 * ''   : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Valid_Voltage'
111	 * ''   : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination'
112	 * ''   : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Tilt_Tele_Enable_Condition'
113	 * ''   : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Down'
114	 * ''   : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Forward'
115	 * ''   : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Rearward'
116	 * ''   : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Tele_Forward_Status'
117	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Tele_Rearward_Status'
118	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Tilt_Down_Status'
119	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Tilt_Up_Status'
120	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Up'
121	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Down/Tilt_Down_Debounce_Logic'
122	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Forward/Tele_Forward_Debounce_Logic'
123	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Rearward/Tele_Rearward_Debounce_Logic'
124	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Tele_Forward_Status/Compare To Constant'
125	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Tele_Rearward_Status/Compare To Constant'
126	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Tilt_Down_Status/Compare To Constant'
127	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Tilt_Up_Status/Compare To Constant'
128	 * ''  : 'Tilt_Telescopic_Switch/Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Up/Tilt_Up_Debounce_Logic'
129	 */
130	#endif                                 /* RTW_HEADER_Tilt_Telescopic_Switch_h_ */
131	
132	/*
133	 * File trailer for generated code.
134	 *
135	 * [EOF]
136	 */
137	

 

 

 

 

/*
 * File: Tilt_Telescopic_Switch.c
 *
 * Code generated for Simulink model 'Tilt_Telescopic_Switch'.
 *
 * Model version                  : 1.32
 * Simulink Coder version         : 8.10 (R2016a) 10-Feb-2016
 * C/C++ source code generated on : Mon Jul 13 10:48:09 2020
 *
 * Target selection: ert.tlc
 * Embedded hardware selection: Intel->x86-64 (Windows64)
 * Code generation objectives: Unspecified
 * Validation result: Not run
 */

#include "Tilt_Telescopic_Switch.h"
#include "Tilt_Telescopic_Switch_private.h"

/* Named constants for Chart: '/Tilt_Down_Debounce_Logic' */
#define Tilt_Telesco_IN_NO_ACTIVE_CHILD ((uint8_T)0U)
#define Tilt_Telescopic_IN_Off_Debounce ((uint8_T)1U)
#define Tilt_Telescopic_S_IN_Stuck_Wait ((uint8_T)6U)
#define Tilt_Telescopic_Swi_IN_Debounce ((uint8_T)1U)
#define Tilt_Telescopic_Swit_IN_Pressed ((uint8_T)4U)
#define Tilt_Telescopic_Switch_IN_Off  ((uint8_T)3U)
#define Tilt_Telescopic_Switch_IN_Stuck ((uint8_T)5U)
#define Tilt_Telescopic__IN_Not_Pressed ((uint8_T)2U)
#define Tilt_Telescopic__IN_On_Debounce ((uint8_T)2U)

/* Block signals (auto storage) */
B_Tilt_Telescopic_Switch_T Tilt_Telescopic_Switch_B;

/* Block states (auto storage) */
DW_Tilt_Telescopic_Switch_T Tilt_Telescopic_Switch_DW;

/* Real-time model */
RT_MODEL_Tilt_Telescopic_Swit_T Tilt_Telescopic_Switch_M_;
RT_MODEL_Tilt_Telescopic_Swit_T *const Tilt_Telescopic_Switch_M =
  &Tilt_Telescopic_Switch_M_;

/* Model step function for TID0 */
void Tilt_Telescopic_Switch_step0(void) /* Sample time: [1.0E-5s, 0.0s] */
{
  /* (no output/update code required) */
}

/* Model step function for TID1 */
void Tilt_Telescopic_Switch_step1(void) /* Sample time: [0.01s, 0.0s] */
{
  /* Outputs for Enabled SubSystem: '/Switch_Pos_Status_Determination' incorporates:
   *  EnablePort: '/Enable'
   */
  /* Logic: '/Logical Operator' incorporates:
   *  Inport: '/ Input_Voltage'
   *  Inport: '/Tilt_Tele_Config_Param'
   *  Logic: '/Logical Operator'
   *  RelationalOperator: '/Relational Operator'
   *  RelationalOperator: '/Relational Operator1'
   */
  if ((Input_Voltage >= 10) && (Input_Voltage <= 20) && Tilt_Tele_Config_Param)
  {
    if (!Tilt_Telescopic_Switch_DW.Switch_Pos_Status_Determination) {
      Tilt_Telescopic_Switch_DW.Switch_Pos_Status_Determination = true;
    }

    /* Chart: '/Tilt_Down_Debounce_Logic' incorporates:
     *  Constant: '/Constant'
     *  Constant: '/Constant1'
     *  Constant: '/Constant2'
     *  DataStoreRead: '/Data Store Read'
     *  Inport: '/Tilt_Down_Input'
     */
    if (Tilt_Telescopic_Switch_DW.temporalCounter_i1_o < MAX_uint32_T) {
      Tilt_Telescopic_Switch_DW.temporalCounter_i1_o++;
    }

    /* Gateway: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Down/Tilt_Down_Debounce_Logic */
    /* During: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Down/Tilt_Down_Debounce_Logic */
    if (Tilt_Telescopic_Switch_DW.is_active_c1_Tilt_Telescopic_Sw == 0U) {
      /* Entry: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Down/Tilt_Down_Debounce_Logic */
      Tilt_Telescopic_Switch_DW.is_active_c1_Tilt_Telescopic_Sw = 1U;

      /* Entry Internal: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Down/Tilt_Down_Debounce_Logic */
      /* Transition: ':2' */
      Tilt_Telescopic_Switch_DW.is_c1_Tilt_Telescopic_Switch =
        Tilt_Telescopic__IN_Not_Pressed;

      /* Entry 'Not_Pressed': ':1' */
      Tilt_Telescopic_Switch_B.Down_Switch_Output = false;
    } else {
      switch (Tilt_Telescopic_Switch_DW.is_c1_Tilt_Telescopic_Switch) {
       case Tilt_Telescopic_Swi_IN_Debounce:
        /* During 'Debounce': ':4' */
        if ((Tilt_Telescopic_Switch_DW.is_Debounce_e !=
             Tilt_Telescopic_IN_Off_Debounce) &&
            (Tilt_Telescopic_Switch_DW.temporalCounter_i1_o >= (uint32_T)ceil
             ((real_T)K_Switch_Debounce_TIme / 0.01 - 1.0E-10))) {
          /* During 'On_Debounce': ':5' */
          /* Transition: ':12' */
          Tilt_Telescopic_Switch_DW.is_Debounce_e =
            Tilt_Telesco_IN_NO_ACTIVE_CHILD;
          Tilt_Telescopic_Switch_DW.is_c1_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swit_IN_Pressed;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1_o = 0U;

          /* Entry 'Pressed': ':8' */
          Tilt_Telescopic_Switch_B.Down_Switch_Output = true;
        } else {
          /* During 'Off_Debounce': ':6' */
        }
        break;

       case Tilt_Telescopic__IN_Not_Pressed:
        /* During 'Not_Pressed': ':1' */
        if ((!Tilt_Down_Stuck_Switch) && Tilt_Down_Input) {
          /* Transition: ':7' */
          Tilt_Telescopic_Switch_DW.is_c1_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swi_IN_Debounce;
          Tilt_Telescopic_Switch_DW.is_Debounce_e =
            Tilt_Telescopic__IN_On_Debounce;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1_o = 0U;
        }
        break;

       case Tilt_Telescopic_Switch_IN_Off:
        /* During 'Off': ':11' */
        if (Tilt_Telescopic_Switch_DW.temporalCounter_i1_o >= (uint32_T)ceil
            ((real_T)K_Switch_Release_Time / 0.01 - 1.0E-10)) {
          /* Transition: ':16' */
          Tilt_Telescopic_Switch_DW.is_c1_Tilt_Telescopic_Switch =
            Tilt_Telescopic__IN_Not_Pressed;

          /* Entry 'Not_Pressed': ':1' */
          Tilt_Telescopic_Switch_B.Down_Switch_Output = false;
        }
        break;

       case Tilt_Telescopic_Swit_IN_Pressed:
        /* During 'Pressed': ':8' */
        if (Tilt_Telescopic_Switch_DW.temporalCounter_i1_o >= (uint32_T)ceil
            ((real_T)(K_Switch_Stuck_Time - K_Switch_Debounce_TIme) / 0.01 -
             1.0E-10)) {
          /* Transition: ':13' */
          Tilt_Telescopic_Switch_DW.is_c1_Tilt_Telescopic_Switch =
            Tilt_Telescopic_S_IN_Stuck_Wait;
        } else {
          /* Transition: ':17' */
          Tilt_Telescopic_Switch_DW.is_c1_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swi_IN_Debounce;
          Tilt_Telescopic_Switch_DW.is_Debounce_e =
            Tilt_Telescopic_IN_Off_Debounce;
        }
        break;

       case Tilt_Telescopic_Switch_IN_Stuck:
        /* During 'Stuck': ':10' */
        if (!Tilt_Down_Input) {
          /* Transition: ':15' */
          Tilt_Telescopic_Switch_DW.is_c1_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Switch_IN_Off;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1_o = 0U;
        }
        break;

       default:
        /* During 'Stuck_Wait': ':9' */
        if (Tilt_Down_Input) {
          /* Transition: ':14' */
          Tilt_Telescopic_Switch_DW.is_c1_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Switch_IN_Stuck;

          /* Entry 'Stuck': ':10' */
          Tilt_Telescopic_Switch_B.Down_Switch_Output = false;
          Tilt_Telescopic_Switch_B.Switch_Stuck_k = true;
        }
        break;
      }
    }

    /* End of Chart: '/Tilt_Down_Debounce_Logic' */

    /* DataStoreWrite: '/Data Store Write' */
    Tilt_Down_Stuck_Switch = Tilt_Telescopic_Switch_B.Switch_Stuck_k;

    /* Chart: '/Tele_Forward_Debounce_Logic' incorporates:
     *  Constant: '/Constant'
     *  Constant: '/Constant1'
     *  Constant: '/Constant2'
     *  DataStoreRead: '/Data Store Read'
     *  Inport: '/Tele_Forward_Input'
     */
    if (Tilt_Telescopic_Switch_DW.temporalCounter_i1_h < MAX_uint32_T) {
      Tilt_Telescopic_Switch_DW.temporalCounter_i1_h++;
    }

    /* Gateway: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Forward/Tele_Forward_Debounce_Logic */
    /* During: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Forward/Tele_Forward_Debounce_Logic */
    if (Tilt_Telescopic_Switch_DW.is_active_c2_Tilt_Telescopic_Sw == 0U) {
      /* Entry: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Forward/Tele_Forward_Debounce_Logic */
      Tilt_Telescopic_Switch_DW.is_active_c2_Tilt_Telescopic_Sw = 1U;

      /* Entry Internal: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Forward/Tele_Forward_Debounce_Logic */
      /* Transition: ':2' */
      Tilt_Telescopic_Switch_DW.is_c2_Tilt_Telescopic_Switch =
        Tilt_Telescopic__IN_Not_Pressed;

      /* Entry 'Not_Pressed': ':1' */
      Tilt_Telescopic_Switch_B.Forward_Switch_Output = false;
    } else {
      switch (Tilt_Telescopic_Switch_DW.is_c2_Tilt_Telescopic_Switch) {
       case Tilt_Telescopic_Swi_IN_Debounce:
        /* During 'Debounce': ':4' */
        if ((Tilt_Telescopic_Switch_DW.is_Debounce_j !=
             Tilt_Telescopic_IN_Off_Debounce) &&
            (Tilt_Telescopic_Switch_DW.temporalCounter_i1_h >= (uint32_T)ceil
             ((real_T)K_Switch_Debounce_TIme / 0.01 - 1.0E-10))) {
          /* During 'On_Debounce': ':5' */
          /* Transition: ':12' */
          Tilt_Telescopic_Switch_DW.is_Debounce_j =
            Tilt_Telesco_IN_NO_ACTIVE_CHILD;
          Tilt_Telescopic_Switch_DW.is_c2_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swit_IN_Pressed;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1_h = 0U;

          /* Entry 'Pressed': ':8' */
          Tilt_Telescopic_Switch_B.Forward_Switch_Output = true;
        } else {
          /* During 'Off_Debounce': ':6' */
        }
        break;

       case Tilt_Telescopic__IN_Not_Pressed:
        /* During 'Not_Pressed': ':1' */
        if ((!Tilt_Forward_Stuck_Switch) && Tele_Forward_Input) {
          /* Transition: ':7' */
          Tilt_Telescopic_Switch_DW.is_c2_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swi_IN_Debounce;
          Tilt_Telescopic_Switch_DW.is_Debounce_j =
            Tilt_Telescopic__IN_On_Debounce;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1_h = 0U;
        }
        break;

       case Tilt_Telescopic_Switch_IN_Off:
        /* During 'Off': ':11' */
        if (Tilt_Telescopic_Switch_DW.temporalCounter_i1_h >= (uint32_T)ceil
            ((real_T)K_Switch_Release_Time / 0.01 - 1.0E-10)) {
          /* Transition: ':16' */
          Tilt_Telescopic_Switch_DW.is_c2_Tilt_Telescopic_Switch =
            Tilt_Telescopic__IN_Not_Pressed;

          /* Entry 'Not_Pressed': ':1' */
          Tilt_Telescopic_Switch_B.Forward_Switch_Output = false;
        }
        break;

       case Tilt_Telescopic_Swit_IN_Pressed:
        /* During 'Pressed': ':8' */
        if (Tilt_Telescopic_Switch_DW.temporalCounter_i1_h >= (uint32_T)ceil
            ((real_T)(K_Switch_Stuck_Time - K_Switch_Debounce_TIme) / 0.01 -
             1.0E-10)) {
          /* Transition: ':13' */
          Tilt_Telescopic_Switch_DW.is_c2_Tilt_Telescopic_Switch =
            Tilt_Telescopic_S_IN_Stuck_Wait;
        } else {
          /* Transition: ':17' */
          Tilt_Telescopic_Switch_DW.is_c2_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swi_IN_Debounce;
          Tilt_Telescopic_Switch_DW.is_Debounce_j =
            Tilt_Telescopic_IN_Off_Debounce;
        }
        break;

       case Tilt_Telescopic_Switch_IN_Stuck:
        /* During 'Stuck': ':10' */
        if (!Tele_Forward_Input) {
          /* Transition: ':15' */
          Tilt_Telescopic_Switch_DW.is_c2_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Switch_IN_Off;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1_h = 0U;
        }
        break;

       default:
        /* During 'Stuck_Wait': ':9' */
        if (Tele_Forward_Input) {
          /* Transition: ':14' */
          Tilt_Telescopic_Switch_DW.is_c2_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Switch_IN_Stuck;

          /* Entry 'Stuck': ':10' */
          Tilt_Telescopic_Switch_B.Forward_Switch_Output = false;
          Tilt_Telescopic_Switch_B.Switch_Stuck_l = true;
        }
        break;
      }
    }

    /* End of Chart: '/Tele_Forward_Debounce_Logic' */

    /* DataStoreWrite: '/Data Store Write' */
    Tilt_Forward_Stuck_Switch = Tilt_Telescopic_Switch_B.Switch_Stuck_l;

    /* Chart: '/Tele_Rearward_Debounce_Logic' incorporates:
     *  Constant: '/Constant'
     *  Constant: '/Constant1'
     *  Constant: '/Constant2'
     *  DataStoreRead: '/Data Store Read'
     *  Inport: '/Tele_Rearward_Input'
     */
    if (Tilt_Telescopic_Switch_DW.temporalCounter_i1_k < MAX_uint32_T) {
      Tilt_Telescopic_Switch_DW.temporalCounter_i1_k++;
    }

    /* Gateway: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Rearward/Tele_Rearward_Debounce_Logic */
    /* During: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Rearward/Tele_Rearward_Debounce_Logic */
    if (Tilt_Telescopic_Switch_DW.is_active_c4_Tilt_Telescopic_Sw == 0U) {
      /* Entry: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Rearward/Tele_Rearward_Debounce_Logic */
      Tilt_Telescopic_Switch_DW.is_active_c4_Tilt_Telescopic_Sw = 1U;

      /* Entry Internal: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Rearward/Tele_Rearward_Debounce_Logic */
      /* Transition: ':2' */
      Tilt_Telescopic_Switch_DW.is_c4_Tilt_Telescopic_Switch =
        Tilt_Telescopic__IN_Not_Pressed;

      /* Entry 'Not_Pressed': ':1' */
      Tilt_Telescopic_Switch_B.Rearward_Switch_Output = false;
    } else {
      switch (Tilt_Telescopic_Switch_DW.is_c4_Tilt_Telescopic_Switch) {
       case Tilt_Telescopic_Swi_IN_Debounce:
        /* During 'Debounce': ':4' */
        if ((Tilt_Telescopic_Switch_DW.is_Debounce_h !=
             Tilt_Telescopic_IN_Off_Debounce) &&
            (Tilt_Telescopic_Switch_DW.temporalCounter_i1_k >= (uint32_T)ceil
             ((real_T)K_Switch_Debounce_TIme / 0.01 - 1.0E-10))) {
          /* During 'On_Debounce': ':5' */
          /* Transition: ':12' */
          Tilt_Telescopic_Switch_DW.is_Debounce_h =
            Tilt_Telesco_IN_NO_ACTIVE_CHILD;
          Tilt_Telescopic_Switch_DW.is_c4_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swit_IN_Pressed;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1_k = 0U;

          /* Entry 'Pressed': ':8' */
          Tilt_Telescopic_Switch_B.Rearward_Switch_Output = true;
        } else {
          /* During 'Off_Debounce': ':6' */
        }
        break;

       case Tilt_Telescopic__IN_Not_Pressed:
        /* During 'Not_Pressed': ':1' */
        if ((!Tele_Rearward_Stuck_Switch) && Tele_Rearward_Input) {
          /* Transition: ':7' */
          Tilt_Telescopic_Switch_DW.is_c4_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swi_IN_Debounce;
          Tilt_Telescopic_Switch_DW.is_Debounce_h =
            Tilt_Telescopic__IN_On_Debounce;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1_k = 0U;
        }
        break;

       case Tilt_Telescopic_Switch_IN_Off:
        /* During 'Off': ':11' */
        if (Tilt_Telescopic_Switch_DW.temporalCounter_i1_k >= (uint32_T)ceil
            ((real_T)K_Switch_Release_Time / 0.01 - 1.0E-10)) {
          /* Transition: ':16' */
          Tilt_Telescopic_Switch_DW.is_c4_Tilt_Telescopic_Switch =
            Tilt_Telescopic__IN_Not_Pressed;

          /* Entry 'Not_Pressed': ':1' */
          Tilt_Telescopic_Switch_B.Rearward_Switch_Output = false;
        }
        break;

       case Tilt_Telescopic_Swit_IN_Pressed:
        /* During 'Pressed': ':8' */
        if (Tilt_Telescopic_Switch_DW.temporalCounter_i1_k >= (uint32_T)ceil
            ((real_T)(K_Switch_Stuck_Time - K_Switch_Debounce_TIme) / 0.01 -
             1.0E-10)) {
          /* Transition: ':13' */
          Tilt_Telescopic_Switch_DW.is_c4_Tilt_Telescopic_Switch =
            Tilt_Telescopic_S_IN_Stuck_Wait;
        } else {
          /* Transition: ':17' */
          Tilt_Telescopic_Switch_DW.is_c4_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swi_IN_Debounce;
          Tilt_Telescopic_Switch_DW.is_Debounce_h =
            Tilt_Telescopic_IN_Off_Debounce;
        }
        break;

       case Tilt_Telescopic_Switch_IN_Stuck:
        /* During 'Stuck': ':10' */
        if (!Tele_Rearward_Input) {
          /* Transition: ':15' */
          Tilt_Telescopic_Switch_DW.is_c4_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Switch_IN_Off;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1_k = 0U;
        }
        break;

       default:
        /* During 'Stuck_Wait': ':9' */
        if (Tele_Rearward_Input) {
          /* Transition: ':14' */
          Tilt_Telescopic_Switch_DW.is_c4_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Switch_IN_Stuck;

          /* Entry 'Stuck': ':10' */
          Tilt_Telescopic_Switch_B.Rearward_Switch_Output = false;
          Tilt_Telescopic_Switch_B.Switch_Stuck_m = true;
        }
        break;
      }
    }

    /* End of Chart: '/Tele_Rearward_Debounce_Logic' */

    /* DataStoreWrite: '/Data Store Write' */
    Tele_Rearward_Stuck_Switch = Tilt_Telescopic_Switch_B.Switch_Stuck_m;

    /* Chart: '/Tilt_Up_Debounce_Logic' incorporates:
     *  Constant: '/Constant'
     *  Constant: '/Constant1'
     *  Constant: '/Constant2'
     *  DataStoreRead: '/Data Store Read'
     *  Inport: '/Tilt_up_Input'
     */
    if (Tilt_Telescopic_Switch_DW.temporalCounter_i1 < MAX_uint32_T) {
      Tilt_Telescopic_Switch_DW.temporalCounter_i1++;
    }

    /* Gateway: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Up/Tilt_Up_Debounce_Logic */
    /* During: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Up/Tilt_Up_Debounce_Logic */
    if (Tilt_Telescopic_Switch_DW.is_active_c3_Tilt_Telescopic_Sw == 0U) {
      /* Entry: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Up/Tilt_Up_Debounce_Logic */
      Tilt_Telescopic_Switch_DW.is_active_c3_Tilt_Telescopic_Sw = 1U;

      /* Entry Internal: Tilt_Tele_Switch/Power_Tilt_Tele/Switch_Pos_Status_Determination/Up/Tilt_Up_Debounce_Logic */
      /* Transition: ':2' */
      Tilt_Telescopic_Switch_DW.is_c3_Tilt_Telescopic_Switch =
        Tilt_Telescopic__IN_Not_Pressed;

      /* Entry 'Not_Pressed': ':1' */
      Tilt_Telescopic_Switch_B.Up_Switch_Output = false;
    } else {
      switch (Tilt_Telescopic_Switch_DW.is_c3_Tilt_Telescopic_Switch) {
       case Tilt_Telescopic_Swi_IN_Debounce:
        /* During 'Debounce': ':4' */
        if ((Tilt_Telescopic_Switch_DW.is_Debounce !=
             Tilt_Telescopic_IN_Off_Debounce) &&
            (Tilt_Telescopic_Switch_DW.temporalCounter_i1 >= (uint32_T)ceil
             ((real_T)K_Switch_Debounce_TIme / 0.01 - 1.0E-10))) {
          /* During 'On_Debounce': ':5' */
          /* Transition: ':12' */
          Tilt_Telescopic_Switch_DW.is_Debounce =
            Tilt_Telesco_IN_NO_ACTIVE_CHILD;
          Tilt_Telescopic_Switch_DW.is_c3_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swit_IN_Pressed;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1 = 0U;

          /* Entry 'Pressed': ':8' */
          Tilt_Telescopic_Switch_B.Up_Switch_Output = true;
        } else {
          /* During 'Off_Debounce': ':6' */
        }
        break;

       case Tilt_Telescopic__IN_Not_Pressed:
        /* During 'Not_Pressed': ':1' */
        if ((!Tilt_Up_Stuck_Switch) && Tilt_up_Input) {
          /* Transition: ':7' */
          Tilt_Telescopic_Switch_DW.is_c3_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swi_IN_Debounce;
          Tilt_Telescopic_Switch_DW.is_Debounce =
            Tilt_Telescopic__IN_On_Debounce;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1 = 0U;
        }
        break;

       case Tilt_Telescopic_Switch_IN_Off:
        /* During 'Off': ':11' */
        if (Tilt_Telescopic_Switch_DW.temporalCounter_i1 >= (uint32_T)ceil
            ((real_T)K_Switch_Release_Time / 0.01 - 1.0E-10)) {
          /* Transition: ':16' */
          Tilt_Telescopic_Switch_DW.is_c3_Tilt_Telescopic_Switch =
            Tilt_Telescopic__IN_Not_Pressed;

          /* Entry 'Not_Pressed': ':1' */
          Tilt_Telescopic_Switch_B.Up_Switch_Output = false;
        }
        break;

       case Tilt_Telescopic_Swit_IN_Pressed:
        /* During 'Pressed': ':8' */
        if (Tilt_Telescopic_Switch_DW.temporalCounter_i1 >= (uint32_T)ceil
            ((real_T)(K_Switch_Stuck_Time - K_Switch_Debounce_TIme) / 0.01 -
             1.0E-10)) {
          /* Transition: ':13' */
          Tilt_Telescopic_Switch_DW.is_c3_Tilt_Telescopic_Switch =
            Tilt_Telescopic_S_IN_Stuck_Wait;
        } else {
          /* Transition: ':17' */
          Tilt_Telescopic_Switch_DW.is_c3_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Swi_IN_Debounce;
          Tilt_Telescopic_Switch_DW.is_Debounce =
            Tilt_Telescopic_IN_Off_Debounce;
        }
        break;

       case Tilt_Telescopic_Switch_IN_Stuck:
        /* During 'Stuck': ':10' */
        if (!Tilt_up_Input) {
          /* Transition: ':15' */
          Tilt_Telescopic_Switch_DW.is_c3_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Switch_IN_Off;
          Tilt_Telescopic_Switch_DW.temporalCounter_i1 = 0U;
        }
        break;

       default:
        /* During 'Stuck_Wait': ':9' */
        if (Tilt_up_Input) {
          /* Transition: ':14' */
          Tilt_Telescopic_Switch_DW.is_c3_Tilt_Telescopic_Switch =
            Tilt_Telescopic_Switch_IN_Stuck;

          /* Entry 'Stuck': ':10' */
          Tilt_Telescopic_Switch_B.Up_Switch_Output = false;
          Tilt_Telescopic_Switch_B.Switch_Stuck = true;
        }
        break;
      }
    }

    /* End of Chart: '/Tilt_Up_Debounce_Logic' */

    /* DataStoreWrite: '/Data Store Write' */
    Tilt_Up_Stuck_Switch = Tilt_Telescopic_Switch_B.Switch_Stuck;

    /* Switch: '/Switch' incorporates:
     *  Constant: '/Constant'
     *  Constant: '/Off'
     *  Delay: '/Delay'
     *  Delay: '/Delay'
     *  Delay: '/Delay'
     *  Delay: '/Delay'
     *  RelationalOperator: '/Compare'
     *  Sum: '/Add'
     *  Switch: '/Switch'
     *  Switch: '/Switch'
     *  Switch: '/Switch'
     *  Switch: '/Switch1'
     */
    if ((uint8_T)((((uint32_T)Tilt_Telescopic_Switch_B.Up_Switch_Output +
                    Tilt_Telescopic_Switch_B.Down_Switch_Output) +
                   Tilt_Telescopic_Switch_B.Forward_Switch_Output) +
                  Tilt_Telescopic_Switch_B.Rearward_Switch_Output) > 1) {
      Tele_Forward_Switch_Status = Tele_Forward_Switch_Status_Delay;
      Tele_Rearward_Switch_Status = Tele_Rearward_Switch_Status_Delay;
      Tilt_Down_Switch_Status = Tilt_Down_Switch_Status_Delay;
      Tilt_Up_Switch_status = Tilt_Up_Switch_status_Delay;
    } else {
      if (Tilt_Telescopic_Switch_B.Forward_Switch_Output) {
        /* Switch: '/Switch1' incorporates:
         *  Constant: '/Forward'
         */
        Tele_Forward_Switch_Status = TELE_Forward;
      } else {
        Tele_Forward_Switch_Status = TELE_Off;
      }

      /* Switch: '/Switch1' incorporates:
       *  Constant: '/Off'
       *  Constant: '/Rearward'
       *  Constant: '/Off'
       *  Switch: '/Switch1'
       */
      if (Tilt_Telescopic_Switch_B.Rearward_Switch_Output) {
        Tele_Rearward_Switch_Status = TELE_Rearward;
      } else {
        Tele_Rearward_Switch_Status = TELE_Off;
      }

      /* End of Switch: '/Switch1' */

      /* Switch: '/Switch1' incorporates:
       *  Constant: '/Down'
       *  Constant: '/Off'
       */
      if (Tilt_Telescopic_Switch_B.Down_Switch_Output) {
        Tilt_Down_Switch_Status = TILT_Down;
      } else {
        Tilt_Down_Switch_Status = TILT_Off;
      }

      /* End of Switch: '/Switch1' */

      /* Switch: '/Switch1' incorporates:
       *  Constant: '/Off'
       *  Constant: '/Up'
       */
      if (Tilt_Telescopic_Switch_B.Up_Switch_Output) {
        Tilt_Up_Switch_status = TILT_Up;
      } else {
        Tilt_Up_Switch_status = TILT_Off;
      }

      /* End of Switch: '/Switch1' */
    }

    /* End of Switch: '/Switch' */

    /* Update for Delay: '/Delay' */
    Tele_Forward_Switch_Status_Delay = Tele_Forward_Switch_Status;

    /* Update for Delay: '/Delay' */
    Tele_Rearward_Switch_Status_Delay = Tele_Rearward_Switch_Status;

    /* Update for Delay: '/Delay' */
    Tilt_Down_Switch_Status_Delay = Tilt_Down_Switch_Status;

    /* Update for Delay: '/Delay' */
    Tilt_Up_Switch_status_Delay = Tilt_Up_Switch_status;
  } else {
    if (Tilt_Telescopic_Switch_DW.Switch_Pos_Status_Determination) {
      Tilt_Telescopic_Switch_DW.Switch_Pos_Status_Determination = false;
    }
  }

  /* End of Logic: '/Logical Operator' */
  /* End of Outputs for SubSystem: '/Switch_Pos_Status_Determination' */
}

/* Model initialize function */
void Tilt_Telescopic_Switch_initialize(void)
{
  /* Registration code */

  /* initialize error status */
  rtmSetErrorStatus(Tilt_Telescopic_Switch_M, (NULL));

  /* block I/O */
  (void) memset(((void *) &Tilt_Telescopic_Switch_B), 0,
                sizeof(B_Tilt_Telescopic_Switch_T));

  /* custom signals */
  Tele_Forward_Switch_Status = TELE_Forward;
  Tele_Rearward_Switch_Status = TELE_Forward;
  Tilt_Down_Switch_Status = TILT_Up;
  Tilt_Up_Switch_status = TILT_Up;

  /* states (dwork) */
  (void) memset((void *)&Tilt_Telescopic_Switch_DW, 0,
                sizeof(DW_Tilt_Telescopic_Switch_T));

  /* custom states */
  Tele_Forward_Switch_Status_Delay = TELE_Forward;
  Tele_Rearward_Switch_Status_Delay = TELE_Forward;
  Tilt_Down_Switch_Status_Delay = TILT_Up;
  Tilt_Up_Switch_status_Delay = TILT_Up;

  /* SystemInitialize for Enabled SubSystem: '/Switch_Pos_Status_Determination' */
  /* InitializeConditions for Delay: '/Delay' */
  Tele_Forward_Switch_Status_Delay = TELE_Off;

  /* InitializeConditions for Delay: '/Delay' */
  Tele_Rearward_Switch_Status_Delay = TELE_Off;

  /* InitializeConditions for Delay: '/Delay' */
  Tilt_Down_Switch_Status_Delay = TILT_Off;

  /* InitializeConditions for Delay: '/Delay' */
  Tilt_Up_Switch_status_Delay = TILT_Off;

  /* SystemInitialize for Chart: '/Tilt_Down_Debounce_Logic' */
  Tilt_Telescopic_Switch_DW.is_Debounce_e = Tilt_Telesco_IN_NO_ACTIVE_CHILD;
  Tilt_Telescopic_Switch_DW.temporalCounter_i1_o = 0U;
  Tilt_Telescopic_Switch_DW.is_active_c1_Tilt_Telescopic_Sw = 0U;
  Tilt_Telescopic_Switch_DW.is_c1_Tilt_Telescopic_Switch =
    Tilt_Telesco_IN_NO_ACTIVE_CHILD;
  Tilt_Telescopic_Switch_B.Down_Switch_Output = false;
  Tilt_Telescopic_Switch_B.Switch_Stuck_k = false;

  /* SystemInitialize for Chart: '/Tele_Forward_Debounce_Logic' */
  Tilt_Telescopic_Switch_DW.is_Debounce_j = Tilt_Telesco_IN_NO_ACTIVE_CHILD;
  Tilt_Telescopic_Switch_DW.temporalCounter_i1_h = 0U;
  Tilt_Telescopic_Switch_DW.is_active_c2_Tilt_Telescopic_Sw = 0U;
  Tilt_Telescopic_Switch_DW.is_c2_Tilt_Telescopic_Switch =
    Tilt_Telesco_IN_NO_ACTIVE_CHILD;
  Tilt_Telescopic_Switch_B.Forward_Switch_Output = false;
  Tilt_Telescopic_Switch_B.Switch_Stuck_l = false;

  /* SystemInitialize for Chart: '/Tele_Rearward_Debounce_Logic' */
  Tilt_Telescopic_Switch_DW.is_Debounce_h = Tilt_Telesco_IN_NO_ACTIVE_CHILD;
  Tilt_Telescopic_Switch_DW.temporalCounter_i1_k = 0U;
  Tilt_Telescopic_Switch_DW.is_active_c4_Tilt_Telescopic_Sw = 0U;
  Tilt_Telescopic_Switch_DW.is_c4_Tilt_Telescopic_Switch =
    Tilt_Telesco_IN_NO_ACTIVE_CHILD;
  Tilt_Telescopic_Switch_B.Rearward_Switch_Output = false;
  Tilt_Telescopic_Switch_B.Switch_Stuck_m = false;

  /* SystemInitialize for Chart: '/Tilt_Up_Debounce_Logic' */
  Tilt_Telescopic_Switch_DW.is_Debounce = Tilt_Telesco_IN_NO_ACTIVE_CHILD;
  Tilt_Telescopic_Switch_DW.temporalCounter_i1 = 0U;
  Tilt_Telescopic_Switch_DW.is_active_c3_Tilt_Telescopic_Sw = 0U;
  Tilt_Telescopic_Switch_DW.is_c3_Tilt_Telescopic_Switch =
    Tilt_Telesco_IN_NO_ACTIVE_CHILD;
  Tilt_Telescopic_Switch_B.Up_Switch_Output = false;
  Tilt_Telescopic_Switch_B.Switch_Stuck = false;

  /* SystemInitialize for Outport: '/Tilt_Up_Switch_status' */
  Tilt_Up_Switch_status = TILT_Up;

  /* SystemInitialize for Outport: '/Tilt_Down_Switch_Status' */
  Tilt_Down_Switch_Status = TILT_Up;

  /* SystemInitialize for Outport: '/Tele_Forward_Switch_Status' */
  Tele_Forward_Switch_Status = TELE_Forward;

  /* SystemInitialize for Outport: '/Tele_Rearward_Switch_Status' */
  Tele_Rearward_Switch_Status = TELE_Forward;

  /* End of SystemInitialize for SubSystem: '/Switch_Pos_Status_Determination' */
}

/* Model terminate function */
void Tilt_Telescopic_Switch_terminate(void)
{
  /* (no terminate code required) */
}

/*
 * File trailer for generated code.
 *
 * [EOF]
 */