Project

Tilt & Telescopic Steering Column Switch using the Stateflow chart in Simulink

DDarshil Anajwala14 Sept 2023

AIM : To create a Model (MBD - Model Base Development/Design) of Tilt & Telescopic Steering Column Switch and Perform MIL and SIL testing using the Stateflow chart in Matlab - Simulink.

INTRODUCTION :

Tilt & Telescopic Steering Column Switch :-

This picture is taken from Infiniti Q70 HEV,2016.

Tilt & Telescopic Steering Column Switch :-
- The Nexteer Power Tilt and Telescope column allows quick, simple steering wheel position adjustment. Tilt and Telescope motors are accessed by a column-mounted toggle switch that allows the driver to effortlessly adjust the upper column and steering wheel to a desired position.
- 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 own 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.

Tilt Wheel
- Tilt steering wheels allow drivers to adjust the steering wheel height with an up and down motion. Depending on the design, the pivot may be slightly forward which allows for greater movement with less tilt. Other pivot placements are practically inside the steering wheel, which allows drivers to adjust the angle with minimal change in steering wheel height.
Telescope Wheel
- Much like the mechanism of a telescope, a telescoping steering wheel allows drivers to move the wheel towards or away from the driver. The process of adjusting the telescoping wheel has become more simplified than in previous years. Rather than unfastening a locknut prior to adjustment, or loosening the sleeve around the steering column like earlier models of the Jaguar XK120 and Ford Thunderbird required, drivers need only to disengage the lock lever or push a control switch on the steering wheel while pulling the wheel forward or backward.

Here, Below picture give information about different types of Tilt & Telescopic Columns and General Specifications.

Below cut section taken from toyota user manual.

This is the flow chart of working of the Tilt & Telescopic Switch.

Tilt and Telescopic switch is the manual operated 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.

OBJECTIVE :

This type of requirement document shared by company to OEM(Original equipment manufacturer) or company.

Requirement-1:
- Switch Handler Power ManaManagement
  - VMin - Defines minimum voltage for a voltage range = 10V
  - VMax - Defines maximum voltage for a voltage range = 20V
  - VBattery - Current Battery Voltage value within minimum maximum range =10V — 20V

Requirement-2:
- Switch Handler Wake Up Behaviour:
  - The Tilt Telescopic Switch interface has to wake up if the Ignition Status is RUN available at the CAN bus. At Wake Up, all the button states shall be in state.

Requirement-3:
- Tilt — Tele Stuck Switch Detection:
  - The Tilt — Tele stuck switch status shall be set as , when the physical switch has been set in that position (up / down / forward / rearward) for more than 120 ms. At this point, the logical state shall be set to and the CAN signal will report to NULL. When the Tilt—Tele stuck status is , the logical state goes to after 100ms. At this point, the CAN signal value is set based on the corresponding state of the physical switch. The ideal debounce time is 50ms.

Requirement-4:
- Switch Denouncing Strategy (Logic) in chart
  - The sensing modules shall debounce the buttons before the Tilt/Telescopic switch function transmits the signal status.

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.

Simulink model of Tilt & Telescopic Steering Column Switch

This is a SLDD file data

% -------------------------------------------------------------------
% Generated by MATLAB on 29-Jan-2022 13:30:06
% MATLAB version: 9.10.0.1602886 (R2021a)
% -------------------------------------------------------------------

Backward_Status = Simulink.Signal;
Backward_Status.CoderInfo.StorageClass = 'Custom';
Backward_Status.CoderInfo.Identifier = '';
Backward_Status.CoderInfo.Alignment = -1;
Backward_Status.CoderInfo.CustomStorageClass = 'Localizable';
Backward_Status.CoderInfo.CustomAttributes.PreserveDimensions = false;
Backward_Status.Description = '';
Backward_Status.DataType = 'Enum: Tele_Input';
Backward_Status.Min = [];
Backward_Status.Max = [];
Backward_Status.DocUnits = '';
Backward_Status.Dimensions = -1;
Backward_Status.DimensionsMode = 'auto';
Backward_Status.Complexity = 'auto';
Backward_Status.SampleTime = -1;
Backward_Status.InitialValue = '';

Battery_Voltage = Simulink.Signal;
Battery_Voltage.CoderInfo.StorageClass = 'Custom';
Battery_Voltage.CoderInfo.Identifier = '';
Battery_Voltage.CoderInfo.Alignment = -1;
Battery_Voltage.CoderInfo.CustomStorageClass = 'Localizable';
Battery_Voltage.CoderInfo.CustomAttributes.PreserveDimensions = false;
Battery_Voltage.Description = '';
Battery_Voltage.DataType = 'boolean';
Battery_Voltage.Min = 0;
Battery_Voltage.Max = 1;
Battery_Voltage.DocUnits = 'V';
Battery_Voltage.Dimensions = -1;
Battery_Voltage.DimensionsMode = 'auto';
Battery_Voltage.Complexity = 'auto';
Battery_Voltage.SampleTime = -1;
Battery_Voltage.InitialValue = '';

Down_Status = Simulink.Signal;
Down_Status.CoderInfo.StorageClass = 'Custom';
Down_Status.CoderInfo.Identifier = '';
Down_Status.CoderInfo.Alignment = -1;
Down_Status.CoderInfo.CustomStorageClass = 'Localizable';
Down_Status.CoderInfo.CustomAttributes.PreserveDimensions = false;
Down_Status.Description = '';
Down_Status.DataType = 'Enum: Tilt_Input';
Down_Status.Min = [];
Down_Status.Max = [];
Down_Status.DocUnits = '';
Down_Status.Dimensions = -1;
Down_Status.DimensionsMode = 'auto';
Down_Status.Complexity = 'auto';
Down_Status.SampleTime = -1;
Down_Status.InitialValue = '';

Down_Switch_Debounce_Time = Simulink.Signal;
Down_Switch_Debounce_Time.CoderInfo.StorageClass = 'ImportedExtern';
Down_Switch_Debounce_Time.CoderInfo.Identifier = '';
Down_Switch_Debounce_Time.CoderInfo.Alignment = -1;
Down_Switch_Debounce_Time.Description = '';
Down_Switch_Debounce_Time.DataType = 'uint8';
Down_Switch_Debounce_Time.Min = 0;
Down_Switch_Debounce_Time.Max = 255;
Down_Switch_Debounce_Time.DocUnits = '';
Down_Switch_Debounce_Time.Dimensions = ...
[1 1];
Down_Switch_Debounce_Time.DimensionsMode = 'auto';
Down_Switch_Debounce_Time.Complexity = 'auto';
Down_Switch_Debounce_Time.SampleTime = -1;
Down_Switch_Debounce_Time.InitialValue = '';

Down_Switch_Output = Simulink.Signal;
Down_Switch_Output.CoderInfo.StorageClass = 'Custom';
Down_Switch_Output.CoderInfo.Identifier = '';
Down_Switch_Output.CoderInfo.Alignment = -1;
Down_Switch_Output.CoderInfo.CustomStorageClass = 'Localizable';
Down_Switch_Output.CoderInfo.CustomAttributes.PreserveDimensions = false;
Down_Switch_Output.Description = '';
Down_Switch_Output.DataType = 'boolean';
Down_Switch_Output.Min = 0;
Down_Switch_Output.Max = 1;
Down_Switch_Output.DocUnits = '';
Down_Switch_Output.Dimensions = -1;
Down_Switch_Output.DimensionsMode = 'auto';
Down_Switch_Output.Complexity = 'auto';
Down_Switch_Output.SampleTime = -1;
Down_Switch_Output.InitialValue = '';

Down_Switch_Release_Time = Simulink.Signal;
Down_Switch_Release_Time.CoderInfo.StorageClass = 'ImportedExtern';
Down_Switch_Release_Time.CoderInfo.Identifier = '';
Down_Switch_Release_Time.CoderInfo.Alignment = -1;
Down_Switch_Release_Time.Description = '';
Down_Switch_Release_Time.DataType = 'uint8';
Down_Switch_Release_Time.Min = 0;
Down_Switch_Release_Time.Max = 255;
Down_Switch_Release_Time.DocUnits = '';
Down_Switch_Release_Time.Dimensions = ...
[1 1];
Down_Switch_Release_Time.DimensionsMode = 'auto';
Down_Switch_Release_Time.Complexity = 'auto';
Down_Switch_Release_Time.SampleTime = -1;
Down_Switch_Release_Time.InitialValue = '';

Down_Switch_Shuck_Time = Simulink.Signal;
Down_Switch_Shuck_Time.CoderInfo.StorageClass = 'ImportedExtern';
Down_Switch_Shuck_Time.CoderInfo.Identifier = '';
Down_Switch_Shuck_Time.CoderInfo.Alignment = -1;
Down_Switch_Shuck_Time.Description = '';
Down_Switch_Shuck_Time.DataType = 'uint8';
Down_Switch_Shuck_Time.Min = 0;
Down_Switch_Shuck_Time.Max = 255;
Down_Switch_Shuck_Time.DocUnits = '';
Down_Switch_Shuck_Time.Dimensions = ...
[1 1];
Down_Switch_Shuck_Time.DimensionsMode = 'auto';
Down_Switch_Shuck_Time.Complexity = 'auto';
Down_Switch_Shuck_Time.SampleTime = -1;
Down_Switch_Shuck_Time.InitialValue = '';

F32 = Simulink.AliasType;
F32.Description = '';
F32.DataScope = 'Auto';
F32.HeaderFile = 'standard_defs.h';
F32.BaseType = 'single';

F64 = Simulink.AliasType;
F64.Description = '';
F64.DataScope = 'Auto';
F64.HeaderFile = 'standard_defs.h';
F64.BaseType = 'double';

FLAG = Simulink.AliasType;
FLAG.Description = '';
FLAG.DataScope = 'Auto';
FLAG.HeaderFile = 'standard_defs.h';
FLAG.BaseType = 'uint8';

Forward_Status = Simulink.Signal;
Forward_Status.CoderInfo.StorageClass = 'Custom';
Forward_Status.CoderInfo.Identifier = '';
Forward_Status.CoderInfo.Alignment = -1;
Forward_Status.CoderInfo.CustomStorageClass = 'Localizable';
Forward_Status.CoderInfo.CustomAttributes.PreserveDimensions = false;
Forward_Status.Description = '';
Forward_Status.DataType = 'Enum: Tele_Input';
Forward_Status.Min = [];
Forward_Status.Max = [];
Forward_Status.DocUnits = '';
Forward_Status.Dimensions = -1;
Forward_Status.DimensionsMode = 'auto';
Forward_Status.Complexity = 'auto';
Forward_Status.SampleTime = -1;
Forward_Status.InitialValue = '';

Forward_Switch_Debounce_Time = Simulink.Signal;
Forward_Switch_Debounce_Time.CoderInfo.StorageClass = 'ImportedExtern';
Forward_Switch_Debounce_Time.CoderInfo.Identifier = '';
Forward_Switch_Debounce_Time.CoderInfo.Alignment = -1;
Forward_Switch_Debounce_Time.Description = '';
Forward_Switch_Debounce_Time.DataType = 'uint8';
Forward_Switch_Debounce_Time.Min = 0;
Forward_Switch_Debounce_Time.Max = 255;
Forward_Switch_Debounce_Time.DocUnits = '';
Forward_Switch_Debounce_Time.Dimensions = ...
[1 1];
Forward_Switch_Debounce_Time.DimensionsMode = 'auto';
Forward_Switch_Debounce_Time.Complexity = 'auto';
Forward_Switch_Debounce_Time.SampleTime = -1;
Forward_Switch_Debounce_Time.InitialValue = '';

Forward_Switch_Output = Simulink.Signal;
Forward_Switch_Output.CoderInfo.StorageClass = 'Custom';
Forward_Switch_Output.CoderInfo.Identifier = '';
Forward_Switch_Output.CoderInfo.Alignment = -1;
Forward_Switch_Output.CoderInfo.CustomStorageClass = 'Localizable';
Forward_Switch_Output.CoderInfo.CustomAttributes.PreserveDimensions = false;
Forward_Switch_Output.Description = '';
Forward_Switch_Output.DataType = 'boolean';
Forward_Switch_Output.Min = 0;
Forward_Switch_Output.Max = 1;
Forward_Switch_Output.DocUnits = '';
Forward_Switch_Output.Dimensions = -1;
Forward_Switch_Output.DimensionsMode = 'auto';
Forward_Switch_Output.Complexity = 'auto';
Forward_Switch_Output.SampleTime = -1;
Forward_Switch_Output.InitialValue = '';

Forward_Switch_Release_Time = Simulink.Signal;
Forward_Switch_Release_Time.CoderInfo.StorageClass = 'ImportedExtern';
Forward_Switch_Release_Time.CoderInfo.Identifier = '';
Forward_Switch_Release_Time.CoderInfo.Alignment = -1;
Forward_Switch_Release_Time.Description = '';
Forward_Switch_Release_Time.DataType = 'uint8';
Forward_Switch_Release_Time.Min = 0;
Forward_Switch_Release_Time.Max = 255;
Forward_Switch_Release_Time.DocUnits = '';
Forward_Switch_Release_Time.Dimensions = ...
[1 1];
Forward_Switch_Release_Time.DimensionsMode = 'auto';
Forward_Switch_Release_Time.Complexity = 'auto';
Forward_Switch_Release_Time.SampleTime = -1;
Forward_Switch_Release_Time.InitialValue = '';

Forward_Switch_Shuck_Time = Simulink.Signal;
Forward_Switch_Shuck_Time.CoderInfo.StorageClass = 'ImportedExtern';
Forward_Switch_Shuck_Time.CoderInfo.Identifier = '';
Forward_Switch_Shuck_Time.CoderInfo.Alignment = -1;
Forward_Switch_Shuck_Time.Description = '';
Forward_Switch_Shuck_Time.DataType = 'uint8';
Forward_Switch_Shuck_Time.Min = 0;
Forward_Switch_Shuck_Time.Max = 255;
Forward_Switch_Shuck_Time.DocUnits = '';
Forward_Switch_Shuck_Time.Dimensions = ...
[1 1];
Forward_Switch_Shuck_Time.DimensionsMode = 'auto';
Forward_Switch_Shuck_Time.Complexity = 'auto';
Forward_Switch_Shuck_Time.SampleTime = -1;
Forward_Switch_Shuck_Time.InitialValue = '';

Input_Voltage = Simulink.Signal;
Input_Voltage.CoderInfo.StorageClass = 'ImportedExtern';
Input_Voltage.CoderInfo.Identifier = '';
Input_Voltage.CoderInfo.Alignment = -1;
Input_Voltage.Description = '';
Input_Voltage.DataType = 'uint8';
Input_Voltage.Min = 0;
Input_Voltage.Max = 50;
Input_Voltage.DocUnits = 'V';
Input_Voltage.Dimensions = 1;
Input_Voltage.DimensionsMode = 'auto';
Input_Voltage.Complexity = 'auto';
Input_Voltage.SampleTime = 0.01;
Input_Voltage.InitialValue = '';

K_Switch_Debounce_Time = Simulink.Parameter;
K_Switch_Debounce_Time.Value = 50;
K_Switch_Debounce_Time.CoderInfo.StorageClass = 'Custom';
K_Switch_Debounce_Time.CoderInfo.Identifier = '';
K_Switch_Debounce_Time.CoderInfo.Alignment = -1;
K_Switch_Debounce_Time.CoderInfo.CustomStorageClass = 'ConstVolatile';
K_Switch_Debounce_Time.CoderInfo.CustomAttributes.HeaderFile = ...
'Tilt_Telescopic_Switch_Fun.h';
K_Switch_Debounce_Time.CoderInfo.CustomAttributes.DefinitionFile = ...
'Tilt_Telescopic_Switch_Fun_ROM.c';
K_Switch_Debounce_Time.CoderInfo.CustomAttributes.Owner = '';
K_Switch_Debounce_Time.CoderInfo.CustomAttributes.PreserveDimensions = false;
K_Switch_Debounce_Time.Description = '';
K_Switch_Debounce_Time.DataType = 'uint8';
K_Switch_Debounce_Time.Min = 0;
K_Switch_Debounce_Time.Max = 255;
K_Switch_Debounce_Time.DocUnits = 'ms';

K_Switch_Release_Time = Simulink.Parameter;
K_Switch_Release_Time.Value = 100;
K_Switch_Release_Time.CoderInfo.StorageClass = 'Custom';
K_Switch_Release_Time.CoderInfo.Identifier = '';
K_Switch_Release_Time.CoderInfo.Alignment = -1;
K_Switch_Release_Time.CoderInfo.CustomStorageClass = 'ConstVolatile';
K_Switch_Release_Time.CoderInfo.CustomAttributes.HeaderFile = ...
'Tilt_Telescopic_Switch_Fun.h';
K_Switch_Release_Time.CoderInfo.CustomAttributes.DefinitionFile = ...
'Tilt_Telescopic_Switch_Fun_ROM.c';
K_Switch_Release_Time.CoderInfo.CustomAttributes.Owner = '';
K_Switch_Release_Time.CoderInfo.CustomAttributes.PreserveDimensions = false;
K_Switch_Release_Time.Description = '';
K_Switch_Release_Time.DataType = 'uint8';
K_Switch_Release_Time.Min = 0;
K_Switch_Release_Time.Max = 255;
K_Switch_Release_Time.DocUnits = 'ms';

K_Switch_Shuck_Time = Simulink.Parameter;
K_Switch_Shuck_Time.Value = 120;
K_Switch_Shuck_Time.CoderInfo.StorageClass = 'Custom';
K_Switch_Shuck_Time.CoderInfo.Identifier = '';
K_Switch_Shuck_Time.CoderInfo.Alignment = -1;
K_Switch_Shuck_Time.CoderInfo.CustomStorageClass = 'ConstVolatile';
K_Switch_Shuck_Time.CoderInfo.CustomAttributes.HeaderFile = ...
'Tilt_Telescopic_Switch_Fun.h';
K_Switch_Shuck_Time.CoderInfo.CustomAttributes.DefinitionFile = ...
'Tilt_Telescopic_Switch_Fun_ROM.c';
K_Switch_Shuck_Time.CoderInfo.CustomAttributes.Owner = '';
K_Switch_Shuck_Time.CoderInfo.CustomAttributes.PreserveDimensions = false;
K_Switch_Shuck_Time.Description = '';
K_Switch_Shuck_Time.DataType = 'uint8';
K_Switch_Shuck_Time.Min = 0;
K_Switch_Shuck_Time.Max = 255;
K_Switch_Shuck_Time.DocUnits = 'ms';

MODE = Simulink.AliasType;
MODE.Description = '';
MODE.DataScope = 'Auto';
MODE.HeaderFile = 'standard_defs.h';
MODE.BaseType = 'uint8';

Max_Volt = Simulink.Signal;
Max_Volt.CoderInfo.StorageClass = 'Custom';
Max_Volt.CoderInfo.Identifier = '';
Max_Volt.CoderInfo.Alignment = -1;
Max_Volt.CoderInfo.CustomStorageClass = 'Localizable';
Max_Volt.CoderInfo.CustomAttributes.PreserveDimensions = false;
Max_Volt.Description = '';
Max_Volt.DataType = 'boolean';
Max_Volt.Min = 0;
Max_Volt.Max = 1;
Max_Volt.DocUnits = '';
Max_Volt.Dimensions = -1;
Max_Volt.DimensionsMode = 'auto';
Max_Volt.Complexity = 'auto';
Max_Volt.SampleTime = -1;
Max_Volt.InitialValue = '';

Min_Volt = Simulink.Signal;
Min_Volt.CoderInfo.StorageClass = 'Custom';
Min_Volt.CoderInfo.Identifier = '';
Min_Volt.CoderInfo.Alignment = -1;
Min_Volt.CoderInfo.CustomStorageClass = 'Localizable';
Min_Volt.CoderInfo.CustomAttributes.PreserveDimensions = false;
Min_Volt.Description = '';
Min_Volt.DataType = 'boolean';
Min_Volt.Min = 0;
Min_Volt.Max = 1;
Min_Volt.DocUnits = '';
Min_Volt.Dimensions = -1;
Min_Volt.DimensionsMode = 'auto';
Min_Volt.Complexity = 'auto';
Min_Volt.SampleTime = -1;
Min_Volt.InitialValue = '';

Rearward_Switch_Debounce_Time = Simulink.Signal;
Rearward_Switch_Debounce_Time.CoderInfo.StorageClass = 'ImportedExtern';
Rearward_Switch_Debounce_Time.CoderInfo.Identifier = '';
Rearward_Switch_Debounce_Time.CoderInfo.Alignment = -1;
Rearward_Switch_Debounce_Time.Description = '';
Rearward_Switch_Debounce_Time.DataType = 'uint8';
Rearward_Switch_Debounce_Time.Min = 0;
Rearward_Switch_Debounce_Time.Max = 255;
Rearward_Switch_Debounce_Time.DocUnits = '';
Rearward_Switch_Debounce_Time.Dimensions = ...
[1 1];
Rearward_Switch_Debounce_Time.DimensionsMode = 'auto';
Rearward_Switch_Debounce_Time.Complexity = 'auto';
Rearward_Switch_Debounce_Time.SampleTime = -1;
Rearward_Switch_Debounce_Time.InitialValue = '';

Rearward_Switch_Output = Simulink.Signal;
Rearward_Switch_Output.CoderInfo.StorageClass = 'Custom';
Rearward_Switch_Output.CoderInfo.Identifier = '';
Rearward_Switch_Output.CoderInfo.Alignment = -1;
Rearward_Switch_Output.CoderInfo.CustomStorageClass = 'Localizable';
Rearward_Switch_Output.CoderInfo.CustomAttributes.PreserveDimensions = false;
Rearward_Switch_Output.Description = '';
Rearward_Switch_Output.DataType = 'boolean';
Rearward_Switch_Output.Min = 0;
Rearward_Switch_Output.Max = 1;
Rearward_Switch_Output.DocUnits = '';
Rearward_Switch_Output.Dimensions = -1;
Rearward_Switch_Output.DimensionsMode = 'auto';
Rearward_Switch_Output.Complexity = 'auto';
Rearward_Switch_Output.SampleTime = -1;
Rearward_Switch_Output.InitialValue = '';

Rearward_Switch_Release_Time = Simulink.Signal;
Rearward_Switch_Release_Time.CoderInfo.StorageClass = 'ImportedExtern';
Rearward_Switch_Release_Time.CoderInfo.Identifier = '';
Rearward_Switch_Release_Time.CoderInfo.Alignment = -1;
Rearward_Switch_Release_Time.Description = '';
Rearward_Switch_Release_Time.DataType = 'uint8';
Rearward_Switch_Release_Time.Min = 0;
Rearward_Switch_Release_Time.Max = 255;
Rearward_Switch_Release_Time.DocUnits = '';
Rearward_Switch_Release_Time.Dimensions = ...
[1 1];
Rearward_Switch_Release_Time.DimensionsMode = 'auto';
Rearward_Switch_Release_Time.Complexity = 'auto';
Rearward_Switch_Release_Time.SampleTime = -1;
Rearward_Switch_Release_Time.InitialValue = '';

Rearward_Switch_Shuck_Time = Simulink.Signal;
Rearward_Switch_Shuck_Time.CoderInfo.StorageClass = 'ImportedExtern';
Rearward_Switch_Shuck_Time.CoderInfo.Identifier = '';
Rearward_Switch_Shuck_Time.CoderInfo.Alignment = -1;
Rearward_Switch_Shuck_Time.Description = '';
Rearward_Switch_Shuck_Time.DataType = 'uint8';
Rearward_Switch_Shuck_Time.Min = 0;
Rearward_Switch_Shuck_Time.Max = 255;
Rearward_Switch_Shuck_Time.DocUnits = '';
Rearward_Switch_Shuck_Time.Dimensions = ...
[1 1];
Rearward_Switch_Shuck_Time.DimensionsMode = 'auto';
Rearward_Switch_Shuck_Time.Complexity = 'auto';
Rearward_Switch_Shuck_Time.SampleTime = -1;
Rearward_Switch_Shuck_Time.InitialValue = '';

S16 = Simulink.AliasType;
S16.Description = '';
S16.DataScope = 'Auto';
S16.HeaderFile = 'standard_defs.h';
S16.BaseType = 'int16';

S32 = Simulink.AliasType;
S32.Description = '';
S32.DataScope = 'Auto';
S32.HeaderFile = 'standard_defs.h';
S32.BaseType = 'int32';

S8 = Simulink.AliasType;
S8.Description = '';
S8.DataScope = 'Auto';
S8.HeaderFile = 'standard_defs.h';
S8.BaseType = 'int8';

SMODE = Simulink.AliasType;
SMODE.Description = '';
SMODE.DataScope = 'Auto';
SMODE.HeaderFile = 'standard_defs.h';
SMODE.BaseType = 'int8';

Tele_Down_Input = Simulink.Signal;
Tele_Down_Input.CoderInfo.StorageClass = 'ImportedExtern';
Tele_Down_Input.CoderInfo.Identifier = '';
Tele_Down_Input.CoderInfo.Alignment = -1;
Tele_Down_Input.Description = '';
Tele_Down_Input.DataType = 'boolean';
Tele_Down_Input.Min = 0;
Tele_Down_Input.Max = 1;
Tele_Down_Input.DocUnits = 'V';
Tele_Down_Input.Dimensions = 1;
Tele_Down_Input.DimensionsMode = 'auto';
Tele_Down_Input.Complexity = 'auto';
Tele_Down_Input.SampleTime = 0.01;
Tele_Down_Input.InitialValue = '';

Tele_Forward_Input = Simulink.Signal;
Tele_Forward_Input.CoderInfo.StorageClass = 'ImportedExtern';
Tele_Forward_Input.CoderInfo.Identifier = '';
Tele_Forward_Input.CoderInfo.Alignment = -1;
Tele_Forward_Input.Description = '';
Tele_Forward_Input.DataType = 'boolean';
Tele_Forward_Input.Min = 0;
Tele_Forward_Input.Max = 1;
Tele_Forward_Input.DocUnits = 'V';
Tele_Forward_Input.Dimensions = 1;
Tele_Forward_Input.DimensionsMode = 'auto';
Tele_Forward_Input.Complexity = 'auto';
Tele_Forward_Input.SampleTime = 0.01;
Tele_Forward_Input.InitialValue = '';

Tele_Forward_Stuck_Switch = Simulink.Signal;
Tele_Forward_Stuck_Switch.CoderInfo.StorageClass = 'ImportedExtern';
Tele_Forward_Stuck_Switch.CoderInfo.Identifier = '';
Tele_Forward_Stuck_Switch.CoderInfo.Alignment = -1;
Tele_Forward_Stuck_Switch.Description = '';
Tele_Forward_Stuck_Switch.DataType = 'boolean';
Tele_Forward_Stuck_Switch.Min = 0;
Tele_Forward_Stuck_Switch.Max = 1;
Tele_Forward_Stuck_Switch.DocUnits = '';
Tele_Forward_Stuck_Switch.Dimensions = -1;
Tele_Forward_Stuck_Switch.DimensionsMode = 'auto';
Tele_Forward_Stuck_Switch.Complexity = 'auto';
Tele_Forward_Stuck_Switch.SampleTime = -1;
Tele_Forward_Stuck_Switch.InitialValue = '';

Tele_Forward_Switch_Status = Simulink.Signal;
Tele_Forward_Switch_Status.CoderInfo.StorageClass = 'Custom';
Tele_Forward_Switch_Status.CoderInfo.Identifier = '';
Tele_Forward_Switch_Status.CoderInfo.Alignment = -1;
Tele_Forward_Switch_Status.CoderInfo.CustomStorageClass = ...
'ExportToFile';
Tele_Forward_Switch_Status.CoderInfo.CustomAttributes.HeaderFile = ...
'Tilt_Telescopic_Switch_Fun.h';
Tele_Forward_Switch_Status.CoderInfo.CustomAttributes.DefinitionFile = ...
'Tilt_Telescopic_Switch_Fun_RAM.c';
Tele_Forward_Switch_Status.CoderInfo.CustomAttributes.Owner = '';
Tele_Forward_Switch_Status.CoderInfo.CustomAttributes.PreserveDimensions = false;
Tele_Forward_Switch_Status.Description = '';
Tele_Forward_Switch_Status.DataType = 'Enum: Tele_Input';
Tele_Forward_Switch_Status.Min = [];
Tele_Forward_Switch_Status.Max = [];
Tele_Forward_Switch_Status.DocUnits = '';
Tele_Forward_Switch_Status.Dimensions = -1;
Tele_Forward_Switch_Status.DimensionsMode = 'auto';
Tele_Forward_Switch_Status.Complexity = 'auto';
Tele_Forward_Switch_Status.SampleTime = -1;
Tele_Forward_Switch_Status.InitialValue = '';

Tele_Forward_Switch_Status_Delay = Simulink.Signal;
Tele_Forward_Switch_Status_Delay.CoderInfo.StorageClass = 'Custom';
Tele_Forward_Switch_Status_Delay.CoderInfo.Identifier = '';
Tele_Forward_Switch_Status_Delay.CoderInfo.Alignment = -1;
Tele_Forward_Switch_Status_Delay.CoderInfo.CustomStorageClass = ...
'Localizable';
Tele_Forward_Switch_Status_Delay.CoderInfo.CustomAttributes.PreserveDimensions = false;
Tele_Forward_Switch_Status_Delay.Description = '';
Tele_Forward_Switch_Status_Delay.DataType = 'Enum: Tele_Input';
Tele_Forward_Switch_Status_Delay.Min = [];
Tele_Forward_Switch_Status_Delay.Max = [];
Tele_Forward_Switch_Status_Delay.DocUnits = '';
Tele_Forward_Switch_Status_Delay.Dimensions = -1;
Tele_Forward_Switch_Status_Delay.DimensionsMode = 'auto';
Tele_Forward_Switch_Status_Delay.Complexity = 'auto';
Tele_Forward_Switch_Status_Delay.SampleTime = -1;
Tele_Forward_Switch_Status_Delay.InitialValue = '';

Tele_Rearward_Input = Simulink.Signal;
Tele_Rearward_Input.CoderInfo.StorageClass = 'ImportedExtern';
Tele_Rearward_Input.CoderInfo.Identifier = '';
Tele_Rearward_Input.CoderInfo.Alignment = -1;
Tele_Rearward_Input.Description = '';
Tele_Rearward_Input.DataType = 'boolean';
Tele_Rearward_Input.Min = 0;
Tele_Rearward_Input.Max = 1;
Tele_Rearward_Input.DocUnits = 'V';
Tele_Rearward_Input.Dimensions = 1;
Tele_Rearward_Input.DimensionsMode = 'auto';
Tele_Rearward_Input.Complexity = 'auto';
Tele_Rearward_Input.SampleTime = 0.01;
Tele_Rearward_Input.InitialValue = '';

Tele_Rearward_Stuck_Switch = Simulink.Signal;
Tele_Rearward_Stuck_Switch.CoderInfo.StorageClass = 'ImportedExtern';
Tele_Rearward_Stuck_Switch.CoderInfo.Identifier = '';
Tele_Rearward_Stuck_Switch.CoderInfo.Alignment = -1;
Tele_Rearward_Stuck_Switch.Description = '';
Tele_Rearward_Stuck_Switch.DataType = 'boolean';
Tele_Rearward_Stuck_Switch.Min = 0;
Tele_Rearward_Stuck_Switch.Max = 1;
Tele_Rearward_Stuck_Switch.DocUnits = '';
Tele_Rearward_Stuck_Switch.Dimensions = -1;
Tele_Rearward_Stuck_Switch.DimensionsMode = 'auto';
Tele_Rearward_Stuck_Switch.Complexity = 'auto';
Tele_Rearward_Stuck_Switch.SampleTime = -1;
Tele_Rearward_Stuck_Switch.InitialValue = '';

Tele_Rearward_Switch_Status = Simulink.Signal;
Tele_Rearward_Switch_Status.CoderInfo.StorageClass = 'Custom';
Tele_Rearward_Switch_Status.CoderInfo.Identifier = '';
Tele_Rearward_Switch_Status.CoderInfo.Alignment = -1;
Tele_Rearward_Switch_Status.CoderInfo.CustomStorageClass = ...
'ExportToFile';
Tele_Rearward_Switch_Status.CoderInfo.CustomAttributes.HeaderFile = ...
'Tilt_Telescopic_Switch_Fun.h';
Tele_Rearward_Switch_Status.CoderInfo.CustomAttributes.DefinitionFile = ...
'Tilt_Telescopic_Switch_Fun_RAM.c';
Tele_Rearward_Switch_Status.CoderInfo.CustomAttributes.Owner = '';
Tele_Rearward_Switch_Status.CoderInfo.CustomAttributes.PreserveDimensions = false;
Tele_Rearward_Switch_Status.Description = '';
Tele_Rearward_Switch_Status.DataType = 'Enum: Tele_Input';
Tele_Rearward_Switch_Status.Min = [];
Tele_Rearward_Switch_Status.Max = [];
Tele_Rearward_Switch_Status.DocUnits = '';
Tele_Rearward_Switch_Status.Dimensions = -1;
Tele_Rearward_Switch_Status.DimensionsMode = 'auto';
Tele_Rearward_Switch_Status.Complexity = 'auto';
Tele_Rearward_Switch_Status.SampleTime = -1;
Tele_Rearward_Switch_Status.InitialValue = '';

Tele_Rearward_Switch_Status_Delay = Simulink.Signal;
Tele_Rearward_Switch_Status_Delay.CoderInfo.StorageClass = 'Custom';
Tele_Rearward_Switch_Status_Delay.CoderInfo.Identifier = '';
Tele_Rearward_Switch_Status_Delay.CoderInfo.Alignment = -1;
Tele_Rearward_Switch_Status_Delay.CoderInfo.CustomStorageClass = ...
'Localizable';
Tele_Rearward_Switch_Status_Delay.CoderInfo.CustomAttributes.PreserveDimensions = false;
Tele_Rearward_Switch_Status_Delay.Description = '';
Tele_Rearward_Switch_Status_Delay.DataType = 'Enum: Tele_Input';
Tele_Rearward_Switch_Status_Delay.Min = [];
Tele_Rearward_Switch_Status_Delay.Max = [];
Tele_Rearward_Switch_Status_Delay.DocUnits = '';
Tele_Rearward_Switch_Status_Delay.Dimensions = -1;
Tele_Rearward_Switch_Status_Delay.DimensionsMode = 'auto';
Tele_Rearward_Switch_Status_Delay.Complexity = 'auto';
Tele_Rearward_Switch_Status_Delay.SampleTime = -1;
Tele_Rearward_Switch_Status_Delay.InitialValue = '';

Tele_Up_Input = Simulink.Signal;
Tele_Up_Input.CoderInfo.StorageClass = 'ImportedExtern';
Tele_Up_Input.CoderInfo.Identifier = '';
Tele_Up_Input.CoderInfo.Alignment = -1;
Tele_Up_Input.Description = '';
Tele_Up_Input.DataType = 'boolean';
Tele_Up_Input.Min = 0;
Tele_Up_Input.Max = 1;
Tele_Up_Input.DocUnits = '';
Tele_Up_Input.Dimensions = 1;
Tele_Up_Input.DimensionsMode = 'auto';
Tele_Up_Input.Complexity = 'auto';
Tele_Up_Input.SampleTime = 0.01;
Tele_Up_Input.InitialValue = '';

Tilt_Down_Stuck_Switch = Simulink.Signal;
Tilt_Down_Stuck_Switch.CoderInfo.StorageClass = 'ImportedExtern';
Tilt_Down_Stuck_Switch.CoderInfo.Identifier = '';
Tilt_Down_Stuck_Switch.CoderInfo.Alignment = -1;
Tilt_Down_Stuck_Switch.Description = '';
Tilt_Down_Stuck_Switch.DataType = 'boolean';
Tilt_Down_Stuck_Switch.Min = 0;
Tilt_Down_Stuck_Switch.Max = 1;
Tilt_Down_Stuck_Switch.DocUnits = '';
Tilt_Down_Stuck_Switch.Dimensions = -1;
Tilt_Down_Stuck_Switch.DimensionsMode = 'auto';
Tilt_Down_Stuck_Switch.Complexity = 'auto';
Tilt_Down_Stuck_Switch.SampleTime = -1;
Tilt_Down_Stuck_Switch.InitialValue = '';

Tilt_Down_Switch_Status = Simulink.Signal;
Tilt_Down_Switch_Status.CoderInfo.StorageClass = 'Custom';
Tilt_Down_Switch_Status.CoderInfo.Identifier = '';
Tilt_Down_Switch_Status.CoderInfo.Alignment = -1;
Tilt_Down_Switch_Status.CoderInfo.CustomStorageClass = 'ExportToFile';
Tilt_Down_Switch_Status.CoderInfo.CustomAttributes.HeaderFile = ...
'Tilt_Telescopic_Switch_Fun.h';
Tilt_Down_Switch_Status.CoderInfo.CustomAttributes.DefinitionFile = ...
'Tilt_Telescopic_Switch_Fun_RAM.c';
Tilt_Down_Switch_Status.CoderInfo.CustomAttributes.Owner = '';
Tilt_Down_Switch_Status.CoderInfo.CustomAttributes.PreserveDimensions = false;
Tilt_Down_Switch_Status.Description = '';
Tilt_Down_Switch_Status.DataType = 'Enum: Tilt_Input';
Tilt_Down_Switch_Status.Min = [];
Tilt_Down_Switch_Status.Max = [];
Tilt_Down_Switch_Status.DocUnits = '';
Tilt_Down_Switch_Status.Dimensions = -1;
Tilt_Down_Switch_Status.DimensionsMode = 'auto';
Tilt_Down_Switch_Status.Complexity = 'auto';
Tilt_Down_Switch_Status.SampleTime = -1;
Tilt_Down_Switch_Status.InitialValue = '';

Tilt_Down_Switch_Status_Delay = Simulink.Signal;
Tilt_Down_Switch_Status_Delay.CoderInfo.StorageClass = 'Custom';
Tilt_Down_Switch_Status_Delay.CoderInfo.Identifier = '';
Tilt_Down_Switch_Status_Delay.CoderInfo.Alignment = -1;
Tilt_Down_Switch_Status_Delay.CoderInfo.CustomStorageClass = ...
'Localizable';
Tilt_Down_Switch_Status_Delay.CoderInfo.CustomAttributes.PreserveDimensions = false;
Tilt_Down_Switch_Status_Delay.Description = '';
Tilt_Down_Switch_Status_Delay.DataType = 'Enum: Tilt_Input';
Tilt_Down_Switch_Status_Delay.Min = [];
Tilt_Down_Switch_Status_Delay.Max = [];
Tilt_Down_Switch_Status_Delay.DocUnits = '';
Tilt_Down_Switch_Status_Delay.Dimensions = -1;
Tilt_Down_Switch_Status_Delay.DimensionsMode = 'auto';
Tilt_Down_Switch_Status_Delay.Complexity = 'auto';
Tilt_Down_Switch_Status_Delay.SampleTime = -1;
Tilt_Down_Switch_Status_Delay.InitialValue = '';

Tilt_Tele_Config_Para = Simulink.Signal;
Tilt_Tele_Config_Para.CoderInfo.StorageClass = 'ImportedExtern';
Tilt_Tele_Config_Para.CoderInfo.Identifier = '';
Tilt_Tele_Config_Para.CoderInfo.Alignment = -1;
Tilt_Tele_Config_Para.Description = '';
Tilt_Tele_Config_Para.DataType = 'boolean';
Tilt_Tele_Config_Para.Min = 0;
Tilt_Tele_Config_Para.Max = 1;
Tilt_Tele_Config_Para.DocUnits = '';
Tilt_Tele_Config_Para.Dimensions = 1;
Tilt_Tele_Config_Para.DimensionsMode = 'auto';
Tilt_Tele_Config_Para.Complexity = 'auto';
Tilt_Tele_Config_Para.SampleTime = 0.01;
Tilt_Tele_Config_Para.InitialValue = '';

Tilt_Tele_Enabled = Simulink.Signal;
Tilt_Tele_Enabled.CoderInfo.StorageClass = 'Custom';
Tilt_Tele_Enabled.CoderInfo.Identifier = '';
Tilt_Tele_Enabled.CoderInfo.Alignment = -1;
Tilt_Tele_Enabled.CoderInfo.CustomStorageClass = 'Localizable';
Tilt_Tele_Enabled.CoderInfo.CustomAttributes.PreserveDimensions = false;
Tilt_Tele_Enabled.Description = '';
Tilt_Tele_Enabled.DataType = 'boolean';
Tilt_Tele_Enabled.Min = 0;
Tilt_Tele_Enabled.Max = 1;
Tilt_Tele_Enabled.DocUnits = '';
Tilt_Tele_Enabled.Dimensions = -1;
Tilt_Tele_Enabled.DimensionsMode = 'auto';
Tilt_Tele_Enabled.Complexity = 'auto';
Tilt_Tele_Enabled.SampleTime = -1;
Tilt_Tele_Enabled.InitialValue = '';

Tilt_Up_Stuck_Switch = Simulink.Signal;
Tilt_Up_Stuck_Switch.CoderInfo.StorageClass = 'ImportedExtern';
Tilt_Up_Stuck_Switch.CoderInfo.Identifier = '';
Tilt_Up_Stuck_Switch.CoderInfo.Alignment = -1;
Tilt_Up_Stuck_Switch.Description = '';
Tilt_Up_Stuck_Switch.DataType = 'boolean';
Tilt_Up_Stuck_Switch.Min = 0;
Tilt_Up_Stuck_Switch.Max = 1;
Tilt_Up_Stuck_Switch.DocUnits = '';
Tilt_Up_Stuck_Switch.Dimensions = -1;
Tilt_Up_Stuck_Switch.DimensionsMode = 'auto';
Tilt_Up_Stuck_Switch.Complexity = 'auto';
Tilt_Up_Stuck_Switch.SampleTime = -1;
Tilt_Up_Stuck_Switch.InitialValue = '';

Tilt_Up_Switch_Status = Simulink.Signal;
Tilt_Up_Switch_Status.CoderInfo.StorageClass = 'Custom';
Tilt_Up_Switch_Status.CoderInfo.Identifier = '';
Tilt_Up_Switch_Status.CoderInfo.Alignment = -1;
Tilt_Up_Switch_Status.CoderInfo.CustomStorageClass = 'ExportToFile';
Tilt_Up_Switch_Status.CoderInfo.CustomAttributes.HeaderFile = ...
'Tilt_Telescopic_Switch_Fun.h';
Tilt_Up_Switch_Status.CoderInfo.CustomAttributes.DefinitionFile = ...
'Tilt_Telescopic_Switch_Fun_RAM.c';
Tilt_Up_Switch_Status.CoderInfo.CustomAttributes.Owner = '';
Tilt_Up_Switch_Status.CoderInfo.CustomAttributes.PreserveDimensions = false;
Tilt_Up_Switch_Status.Description = '';
Tilt_Up_Switch_Status.DataType = 'Enum: Tilt_Input';
Tilt_Up_Switch_Status.Min = [];
Tilt_Up_Switch_Status.Max = [];
Tilt_Up_Switch_Status.DocUnits = '';
Tilt_Up_Switch_Status.Dimensions = -1;
Tilt_Up_Switch_Status.DimensionsMode = 'auto';
Tilt_Up_Switch_Status.Complexity = 'auto';
Tilt_Up_Switch_Status.SampleTime = -1;
Tilt_Up_Switch_Status.InitialValue = '';

Tilt_Up_Switch_Status_Delay = Simulink.Signal;
Tilt_Up_Switch_Status_Delay.CoderInfo.StorageClass = 'Custom';
Tilt_Up_Switch_Status_Delay.CoderInfo.Identifier = '';
Tilt_Up_Switch_Status_Delay.CoderInfo.Alignment = -1;
Tilt_Up_Switch_Status_Delay.CoderInfo.CustomStorageClass = ...
'Localizable';
Tilt_Up_Switch_Status_Delay.CoderInfo.CustomAttributes.PreserveDimensions = false;
Tilt_Up_Switch_Status_Delay.Description = '';
Tilt_Up_Switch_Status_Delay.DataType = 'Enum: Tilt_Input';
Tilt_Up_Switch_Status_Delay.Min = [];
Tilt_Up_Switch_Status_Delay.Max = [];
Tilt_Up_Switch_Status_Delay.DocUnits = '';
Tilt_Up_Switch_Status_Delay.Dimensions = -1;
Tilt_Up_Switch_Status_Delay.DimensionsMode = 'auto';
Tilt_Up_Switch_Status_Delay.Complexity = 'auto';
Tilt_Up_Switch_Status_Delay.SampleTime = -1;
Tilt_Up_Switch_Status_Delay.InitialValue = '';

U16 = Simulink.AliasType;
U16.Description = '';
U16.DataScope = 'Auto';
U16.HeaderFile = 'standard_defs.h';
U16.BaseType = 'uint16';

U32 = Simulink.AliasType;
U32.Description = '';
U32.DataScope = 'Auto';
U32.HeaderFile = 'standard_defs.h';
U32.BaseType = 'uint32';

U8 = Simulink.AliasType;
U8.Description = '';
U8.DataScope = 'Auto';
U8.HeaderFile = 'standard_defs.h';
U8.BaseType = 'uint8';

Up_Status = Simulink.Signal;
Up_Status.CoderInfo.StorageClass = 'Custom';
Up_Status.CoderInfo.Identifier = '';
Up_Status.CoderInfo.Alignment = -1;
Up_Status.CoderInfo.CustomStorageClass = 'Localizable';
Up_Status.CoderInfo.CustomAttributes.PreserveDimensions = false;
Up_Status.Description = '';
Up_Status.DataType = 'Enum: Tilt_Input';
Up_Status.Min = [];
Up_Status.Max = [];
Up_Status.DocUnits = '';
Up_Status.Dimensions = -1;
Up_Status.DimensionsMode = 'auto';
Up_Status.Complexity = 'auto';
Up_Status.SampleTime = -1;
Up_Status.InitialValue = '';

Up_Switch_Debounce_Time = Simulink.Signal;
Up_Switch_Debounce_Time.CoderInfo.StorageClass = 'ImportedExtern';
Up_Switch_Debounce_Time.CoderInfo.Identifier = '';
Up_Switch_Debounce_Time.CoderInfo.Alignment = -1;
Up_Switch_Debounce_Time.Description = '';
Up_Switch_Debounce_Time.DataType = 'uint8';
Up_Switch_Debounce_Time.Min = 0;
Up_Switch_Debounce_Time.Max = 255;
Up_Switch_Debounce_Time.DocUnits = '';
Up_Switch_Debounce_Time.Dimensions = ...
[1 1];
Up_Switch_Debounce_Time.DimensionsMode = 'auto';
Up_Switch_Debounce_Time.Complexity = 'auto';
Up_Switch_Debounce_Time.SampleTime = -1;
Up_Switch_Debounce_Time.InitialValue = '';

Up_Switch_Output = Simulink.Signal;
Up_Switch_Output.CoderInfo.StorageClass = 'Custom';
Up_Switch_Output.CoderInfo.Identifier = '';
Up_Switch_Output.CoderInfo.Alignment = -1;
Up_Switch_Output.CoderInfo.CustomStorageClass = 'Localizable';
Up_Switch_Output.CoderInfo.CustomAttributes.PreserveDimensions = false;
Up_Switch_Output.Description = '';
Up_Switch_Output.DataType = 'boolean';
Up_Switch_Output.Min = 0;
Up_Switch_Output.Max = 1;
Up_Switch_Output.DocUnits = '';
Up_Switch_Output.Dimensions = -1;
Up_Switch_Output.DimensionsMode = 'auto';
Up_Switch_Output.Complexity = 'auto';
Up_Switch_Output.SampleTime = -1;
Up_Switch_Output.InitialValue = '';

Up_Switch_Release_Time = Simulink.Signal;
Up_Switch_Release_Time.CoderInfo.StorageClass = 'ImportedExtern';
Up_Switch_Release_Time.CoderInfo.Identifier = '';
Up_Switch_Release_Time.CoderInfo.Alignment = -1;
Up_Switch_Release_Time.Description = '';
Up_Switch_Release_Time.DataType = 'uint8';
Up_Switch_Release_Time.Min = 0;
Up_Switch_Release_Time.Max = 255;
Up_Switch_Release_Time.DocUnits = '';
Up_Switch_Release_Time.Dimensions = ...
[1 1];
Up_Switch_Release_Time.DimensionsMode = 'auto';
Up_Switch_Release_Time.Complexity = 'auto';
Up_Switch_Release_Time.SampleTime = -1;
Up_Switch_Release_Time.InitialValue = '';

Up_Switch_Shuck_Time = Simulink.Signal;
Up_Switch_Shuck_Time.CoderInfo.StorageClass = 'ImportedExtern';
Up_Switch_Shuck_Time.CoderInfo.Identifier = '';
Up_Switch_Shuck_Time.CoderInfo.Alignment = -1;
Up_Switch_Shuck_Time.Description = '';
Up_Switch_Shuck_Time.DataType = 'uint8';
Up_Switch_Shuck_Time.Min = 0;
Up_Switch_Shuck_Time.Max = 255;
Up_Switch_Shuck_Time.DocUnits = '';
Up_Switch_Shuck_Time.Dimensions = [1 1];
Up_Switch_Shuck_Time.DimensionsMode = 'auto';
Up_Switch_Shuck_Time.Complexity = 'auto';
Up_Switch_Shuck_Time.SampleTime = -1;
Up_Switch_Shuck_Time.InitialValue = '';

Validty_Signal = Simulink.Signal;
Validty_Signal.CoderInfo.StorageClass = 'Custom';
Validty_Signal.CoderInfo.Identifier = '';
Validty_Signal.CoderInfo.Alignment = -1;
Validty_Signal.CoderInfo.CustomStorageClass = 'Localizable';
Validty_Signal.CoderInfo.CustomAttributes.PreserveDimensions = false;
Validty_Signal.Description = '';
Validty_Signal.DataType = 'boolean';
Validty_Signal.Min = 0;
Validty_Signal.Max = 1;
Validty_Signal.DocUnits = '';
Validty_Signal.Dimensions = -1;
Validty_Signal.DimensionsMode = 'auto';
Validty_Signal.Complexity = 'auto';
Validty_Signal.SampleTime = -1;
Validty_Signal.InitialValue = '';

Volt_Max = Simulink.Signal;
Volt_Max.CoderInfo.StorageClass = 'ImportedExtern';
Volt_Max.CoderInfo.Identifier = '';
Volt_Max.CoderInfo.Alignment = -1;
Volt_Max.Description = '';
Volt_Max.DataType = 'uint8';
Volt_Max.Min = 0;
Volt_Max.Max = 255;
Volt_Max.DocUnits = 'V';
Volt_Max.Dimensions = -1;
Volt_Max.DimensionsMode = 'auto';
Volt_Max.Complexity = 'auto';
Volt_Max.SampleTime = -1;
Volt_Max.InitialValue = '';

Volt_Min = Simulink.Signal;
Volt_Min.CoderInfo.StorageClass = 'ImportedExtern';
Volt_Min.CoderInfo.Identifier = '';
Volt_Min.CoderInfo.Alignment = -1;
Volt_Min.Description = '';
Volt_Min.DataType = 'uint8';
Volt_Min.Min = 0;
Volt_Min.Max = 255;
Volt_Min.DocUnits = 'V';
Volt_Min.Dimensions = -1;
Volt_Min.DimensionsMode = 'auto';
Volt_Min.Complexity = 'auto';
Volt_Min.SampleTime = -1;
Volt_Min.InitialValue = '';