3DCrane

Version 1.3

Number of experiment	P of the cart position	P of the payload angle	Figure
1	2.5	−	Fig. 5.10
2	5	−	Fig. 5.10
3	2.5	1	Fig. 5.11
4	5	2	Fig. 5.11
5	5	4	Fig. 5.11

Table 5-1 Parameters for the experiments

	The results of five experiments are presented in Fig. 5.10 and Fig. 5.11. 0 0.5 1 desired x position x position x angle0 0.5 1desired x position x position x angle
	-0.5													-0.5
	0 -1			5			10 15 20 control P set to 2.5		25			30		0 -1			5	10 15 20 control P set to 5		25		30
	Fig. 5.10 Only one controller is active – desired x position of the cart is tracked
	0.5 1				desired x position x position						0.5 1							desired x position x position
	0				x angle						0 x angle
	-0.5										-0.5
	0 -1		5			10 15 control		20		25			30			0 -1	5	10 15 control	20		25	30
		P of the cart position set to 2.5 P of the payload angle set to 1													P of the cart position set to 5 P of the payload angle set to 2

3DCRANE GETTING STARTED

1

desired x position

0.5

x position

x angle 0

-0.5
P of the cart position set to 5
-1		control					P of the payload angle set to 4
0	5	10	15	20	25	30

Fig. 5.11 Two controllers – desired x position of the cart and x angle of the payload are tracked

The left-hand side of Fig. 5.10 shows that the P value set to 2.5 is too small for a proper x position tracking. The static error of x position is large. A higher gain P equal to 5 (the right-hand side of Fig. 5.10) reduces the static error but results in the saturation of control.

In Fig. 5.11 one can see similar results obtained for two active controllers. We focus our attention on the x angle control. The trade-off between two acting controllers is well visible in the upper left-hand picture of Fig. 5.11. One control signal serves for two control purposes: follow the desired value of the cart x position and simultaneously stabilises the payload in its hanging down position.

5.2. Simulation

We can repeat the real-time experiment from the previous section in a purely simulated form.

We invoke the Crane3D_first_model window. Notice two differences. The Crane3D real-time driver block has been replaced by the Crane3D_model simulation model block. The External mode of operation has been replaced by the Normal mode of operation (see Fig. 5.12). All other parts remain as in the real-time experiment.

The interior of Crane3D_model includes the complete nonlinear model described in section 6.4. After clicking on Crane3D_model the mask given in Fig. 5.13 opens. You can set the initial values of 10 variables. You can mark the constant or varying pendulum length. In our example all initial conditions are set to zero except the X position set to 0.55 and Z position set to 0.5 and the last variable t set to -1. Setting t to –1 denotes that the source of time is the RTWT clock.

If you look under the Crane3D_model mask you can see its interior (Fig. 5.14). model3dddm is the executable dll file. The scale factors are set to 34. These parameters relate to friction and tension of the belts.

In opposite to the real-time model it is not necessary to rebuild the model before running. Open Simulation parameters from the menu bar. Notice the solver options: Fixed step and Fixed-step size set to 0.001 in the editable text box. You can start a simulation from the menu bar. When the simulation is running you can watch the results in the scope (see Fig. 5.15). Similarly as in the real time experiment, the data are saved in the scope in the EX1 structural variable.

Plotting four curves as functions of time (Fig. 5.15) is produced by:

>> plot(EX1.time, EX1.signals.values)

We perform simulations related to the experiments 2 and 5 from Table 5-1. The results are visible in Fig. 5.16. They are similar to the results of the real-time experiments. The model reflects characteristic features of the laboratory crane. The model compatibility to the real crane strongly depends on such parameters as the payload lift-line length, the static cart friction, the belt tension, etc. These and other parameters are written into the C source code of the model3ddm.c file attached in the DevDriv directory. If you wish to modify this file please make a copy and introduce the new parameters in the copy. Remember to produce an executable .dll file afterwards.

Fig. 5.15 Simulation data visible in the scope

1

1

desired x position

desired x position

0.5

0.5

x position

x position

0		0
	x angle
-0.5		-0.5	x angle

control

control

-1

-1

Fig. 5.16 Simulation results

0	5	10	15	20	25	30	0	5	10	15	20			25	30
P of the cart position set to 5							P of the cart position set to 5
P of the payload angle set to 0							P of the payload angle set to 4
Only one controller is active – the desired x							Two controllers – the desired x position of
position of the cart is tracked							the cart is tracked and the					x	angle of the
							payload is stabilised

5.3. PID control of load position

In our experiment the cart is following a Lissajous curve. We invoke the Crane3D_impres model from the MATLAB command window (see Fig. 5.17).We put the cart into motion in two directions. The desired cart positions are generated as two sinusoidal signals. There are two generators identical in amplitudes equal to 0.2 m and different in frequencies. The X motion frequency is 0.4 rad/s (Fig. 5.18) and the Y motion frequency is 0.8 0.4 rad/s.

We perform the experiment twice, first time without the P angle controllers and second time, with the P angle controllers set to 20 (see Fig. 5.19).

The cart motion is shown in Fig. 5.20. The thick line represents the cart position in the XY plane (there is no movement in the Z direction). The respective controls and the payload angles are shown in Fig. 5.21 and Fig. 5.22.

0.8

0.6

Y control vs. X control

0.4

0.2

Y angle vs. X angle 0 -0.2 -0.4 -0.6 -0.8 -0.5 0 0.5

Fig. 5.21 The controls (normalised units) and the payload angles [rad] on the XY plane; the angles without control

0.8

0.6

Y control vs. X control

0.4

0.2

Y angle vs. X angle

0 -0.2 -0.4 -0.6 -0.8

-0.4 -0.2 0 0.2 0.4

Fig. 5.22 The controls (normalised units) and the payload angles [rad] on the XY plane; the angles with control

Notice that the control curve in the XY plane for the case of uncontrolled deviations of the payload is smoother than that for the controlled deviations case. The payload deviations are zoomed in Fig. 5.23 and Fig. 5.24 (please notice the scales of deviations).

0.08

0.015 Y angle vs. X angle

0.06

0.01

0.04

0.005

0.02

0 0

Y angle vs. X angle -0.005

-0.02

-0.04

-0.01

-0.06							-0.015
-0.08
-0.06	-0.04	-0.02	0	0.02	0.04	0.06	-0.01	-0.005	0	0.005	0.01
Fig. 5.23 Unstabilised deviations of							Fig. 5.24 Stabilised deviations of the payload
the payload in the X Y plane (in meters)							in the X Y plane (in meters)

The controls in the X and Y directions are shown in Fig. 5.25 and Fig. 5.26. Two cases of control: with and without stabilisation of angles are compared.

0.8

0.5

0.6

0.4

0.3

0.4

0.2

0.2

0.1

0

0 -0.2

-0.1

-0.2

-0.4

-0.3

-0.6 -0.4

-0.8

0 510 15 20 25 0 5 10 15 20 25

Notice that the controls related to the case of angles stabilisation (thick lines in the figures) share their actions between two tasks: tracking a desired position of the cart and stabilising the payload in its down position.

6. CASE STUDY

This section describes nine steps to be performed by the user for collecting data from the real 3DCrane system, identifying a simple crane model and identifying the z displacement. Finally, the optimisation of the 5 DOF PID controller based on the collected data yields an appropriate set of the PID controller’s parameters.

All steps are described in detail below. After clicking on the Simple Model button the following window opens (see Fig. 6.1).

Step 1 and Step 2 have been described in section 4.1. After performing these steps the crane is ready to start an experiment.

Step 3

This step collects the XYZ data. The cart is steered forth and back in the X and Y directions. The payload is lifted up and lowered. These actions run simultaneously due to operating controllers, as illustrated in Fig. 6.2. There are three identical Relay blocks used as controllers. You can see the control ranges by clicking on a block – see Fig. 6.3. The control values change from 0.5 to −0.5 (a half of the maximal excitations). The motion ranges are between 0.3 and 0.5 m.

Before starting the motion set the Base Address first. Click the Set Base Address button in the 3DCrane 3DOF Relay Controller window – see Fig. 6.2. Next, choose Tools from the window menu bar. These pull-down menus execute callback routines when the user selects an individual menu item. Choose the Real_Time Workshop menu and the Build Model submenu. The model is rebuilt. Finally, choose Simulation from the window menu bar and click the Connect to target pull-down menu.

When the system is running observe the real motion of the crane and the plot in the scope – see Fig. 6.4.

The cart velocities in X and Y directions are much alike. The payload moves slower down and up. The angles of the payload are not closed-loop controlled and in consequence the payload oscillates freely.

The Matlab Optimisation Toolbox is required to perform step 4.

Step 4

Click the Identify XYZ Model button. The optimisation procedure starts. The plot illustrated in Fig. 6.5 appears. The following simple linear model of the crane dynamics in the X-axis is assumed K

G (s) = ^x .^xs(T_xs +1) The Identify XYZ Model button calls the CaseStudy_XYZIdent m-file. This routine calls the Crane3D_CSPenaltyXY function. The function invokes simulation of theCrane3D_CSModelXY Simulink model (see Fig. 6.6). If you wish to build your own optimisation procedure all source codes are available. The optimisation procedure (called insideCaseStudy_XYZIdent) uses the fmincon procedure from the MATLAB optimisation library, which finds the constrained minimum of the Crane3D_CSPenaltyXY function. The iterative procedure based on fminunc results in matching real system time responses to the simple model responses.

Finally, we obtain K_x and T_x parameters of the simple model. In this example they have the following numerical values

K_x = 0.173511, T_x= 0.074388.

The final plots after optimisation (shown in Fig. 6.7) indicate that the model matching is successful.

After pressing a key again the program starts. The same procedure is repeated in the Y axis. A similar simple linear model of the crane dynamics in Y-axis is assumed K

G (s) = ^y .

^ys(T_ys +1)

Results obtained for the unmatched model (before optimisation) and the matched model (after optimisation) are visible in Fig. 6.8 and Fig. 6.9.

The following numerical values of K_y and T_y were obtains: K_y = 0.172034, T_y = 0.129360.

If we press a key again then the model optimisation in the Z direction starts (again the simple model is used). The initial stage before optimisation is visible in Fig. 6.10.

After optimisation the following picture is obtained (see Fig. 6.11)

The model matching in the Z direction results in two models identical in form and different in parameters. We have Kp= 0.103062 and Tsp= 0.019731 when the payload is lifted and Km= 0.091699 and Tsm= 0.012947 when the payload is lowered. The model shown in Fig. 6.12, different from that presented in Fig. 6.6, is used.

Step 5 Perform the Go To Center action. Set the payload motionless. After that it is necessary to reset the angle encoders. Go to the Main Control Window and reset the angle encoders.

Step 6

Click on the Collect X Y Data button. The corresponding controller denoted by 3DCrane Angle Excitation opens – see Fig. 6.13. Click Set Address button and rebuild the model. Next choose successively Connect to Target and Start real-time simulation from the pull-down menu. The cart and the rail start to move and stop afterwards. This short (in time) motion gives an impulse to the payload to swing. The system collects angles data.

Step 7

Having collected data of angles trajectories you can start the identification of Z displacement. Click on the Identify Z Displacement button. The angle data are displayed (see Fig. 6.15)

The mathematical pendulum model is assumed. The period of oscillations T is calculated from the formula

lT = 2π

g where l is the mathematical pendulum length and g is the gravity constant. You obtain the values for the period and the length of the pendulum. They are: 1.826 s and 0.822 m in the presented example.

Step 8

We click on the PID Optimisation button to invoke the iterative procedure. This procedure tunes the parameters of the PI controller for each axis using the model given in Fig. 6.17. The performance index is equal to the sum of squares of the differences between the reference signal and the response of the system. The penalty function is also used (see CaseStudy_penaltyPID.m file for details).

The optimisation runs. The temporary system responses to the iterative parameters K_p and

K_i values are displayed in the consecutive three figures. The final results are visible in Fig. 6.18, Fig. 6.19 and Fig. 6.20, and displayed in the MATLAB command window.

In the presented example the PI optimisation results in:

[ Kpx Kix ]= [ 32.9328 8.82428e-007 ]

[ Kpy Kiy ]= [ 19.0999 4.74215e-006 ]

[ Kpz Kiz ]= [ 267.3002 3.414063e-007 ]

The proportional gains are large. This follows from the fact that the time constants in the previously identified models are very small. The models are thus close to non-dynamical systems. In such a case the closed-loop system requires very large K parameters for PI controllers to track the step reference signals.

Remember that the parameters tuned above relate only to the PI controllers of the desired X, Y and Z cart positions. They do not relate to the PID controllers of the X and Y angles.

When the optimisation is finished click 5DOF Experiment button, invoke the Crane3D_CSPID model (see Fig. 6.21 ) and manually introduce the set of new parameters for the X PID and Y PID controllers.

The PID controllers of the X an Y angles have the default K_p values equal to 20. You may change and enlarge these values up to your requirements. However, do remember that this is a trade-off between tracking the desired cart trajectory and the payload stabilisation. Too high K_p values may result in an unstable behaviour of the crane.

Rebuild the model, then open two scopes and start the real-time experiment. The results of the experiment are visible in the scopes (see Fig. 6.22 and Fig. 6.23).

The cart is tracking the reference signals in the form of square waves. Abrupt changes in the cart movement result in oscillations of the payload. These oscillations are immediately dumped due to the P angle controllers operation.

7. Prototyping your own controller in RTWT environment

In this section the process of building your own control system is described. The Real Time Windows Target (RTWT) toolbox is used. An example how to use the Crane3D software is shown later in section 5.3. In this section we give indications how to proceed in the RTWT environment.

Before start, test your MATLAB configuration and compiler installation by building and running an example of real-time application. Real-time

Windows Target includes the model rtvdp.mdl. In the MATLAB Command Window, type

rtvdp

Next, build and run the real-time model. For details refer to the Real-Time Windows Target help, section Installation and Configuration.

To build the system that operates in the real-time mode the user has to:

• create a Simulink model of the control system which consists of the 3DCrane Device Driver and other blocks chosen from the Simulink library,
• build the executable file under RTWT (see the pop-up menus in Fig. 5.1)
• start the real-time code to run from the Simulation/Start real-time code pull-down menus.

7.1. Creating a model

The simplest way to create a Simulink model of the control system is to use one of the models included in the Main Control Window as a template. For example, click on the Pxyz button and save it as MySystem.mdlname. The MySystem Simulink model is shown in Fig.

7.2.

Now, you can modify the model. You have absolute freedom to develop your own controller. Remember to leave the 3DCrane driver model and the Set Base Address button in the window. This is necessary to activate transferring the base address of the I/O card to the model as a MATLAB workspace variable.

Though it is not obligatory, we recommend you to live the multiplexer with the scope and the control saturation blocks. You need a scope to watch how the system runs. You also need the saturation blocks to constraint the controls to match the maximal PWM signals sent to the DC motors. The saturation blocks are built in the Crane 3D driver block. They limit currents to DC motors for safety reasons. However they are not visible for the user who may amaze at the saturation of controls. Other blocks remaining in the window are not necessary for our new project.

Creating your own model on the basis of an old example ensures that all-internal options of the model are set properly. These options are required to proceed with compiling and linking in a proper way. To put the 3DCrane Device Driver into the real-time code a special make-file is required. This file is included to the 3DCrane software.

You can apply most of the blocks from the Simulink library. However, some of them cannot be used (see MathWorks references manual).

The scope block properties are important for appropriate data acquisition and watching how the system runs.

The Scope block properties are defined in the Scope property window (see Fig. 7.3). This window opens after the selection of the Scope/Properties tab. You can gather measurement data to the Matlab Workspacemarking the Save data to workspace checkbox. The data is placed under Variable name. The variable format can be set as structure or matrix. The default Sampling Decimation parameter value is set to 1. This means that each measured point is plotted and saved. Often we choose the Decimation parameter value equal to 5 or 10. This is a good choice to get enough points to describe the signal behaviour and to save the computer memory.

When the Simulink model is ready, click the Tools/External Mode Control Panel option and next click the Signal Triggering button. The window presented in Fig. 7.4 opens. Select XT Scope, set Source as manual, set Duration equal to the number of samples you intend to collect and close the window.

7.2. Code generation and the build process

Once a model of the system has been designed the code for real-time mode can be generated, compiled, linked and downloaded into the processor.

The code is generated by the use of Target Language Compiler (TLC) (see description of the Simulink Target Language). The make-file is used to build and download object files to the target hardware automatically.

First, you have to specify the simulation parameters of your Simulink model in the Simulation parameters dialog box. The RTW page appears when you select the RTW tab (Fig. 7.5). The RTW page allows you to set the real-time build options and then to start the building process of the RTW.DLL executable file.

The system target file name is win_watc.tlc. It manages the code generation process. The crane3d_win_watc.tmf template make-file is devoted to C code generation using the WATCOM 11.0 compiler.

Notice that the crane3d_win_vc.tmf template make-file is also included to the software. It is ready to be used by the Microsoft Visual C++ 6.0 compiler.

Template make-file must correspond to the compiler in use. See section 10 for details.

There are three options which have to be properly marked as shown in Fig. 7.5:

• Inline parameters -not used when building a real-time program,
• Retain.rtw file -if marked, auxiliary information is stored in the file (with .rtw extension),
• Generate code only -if marked, a code is generated but compilation is not performed.

The Solver page appears when you select the Solver tab (Fig. 7.6). The Solver page allows you to set the simulation parameters. Several parameters and options are available in the window. The Fixed-step sizeeditable text box is set to 0.01 (this is the sampling period in seconds).

The Fixed-step solver is obligatory for real-time applications. If you use an arbitrary block from the discrete Simulink library or a block from the driver

library remember that different sampling periods must have a common divider.

The Start time has to be set to 0. The solver has to be selected. In our example the fifth-order integration method − ode5 is chosen.

If all parameters are set properly you can start the DLL executable building process. For this purpose press the Build push button on the RTW page (Fig. 7.5).

Successful compilation and linking processes generate the following message:

Model MyModel.rtd successfully created ### Successful completion of Real-Time Workshop build procedure for model: MyModel

Otherwise, an error massage is displayed in the MATLAB command window.

Before starting the experiment set the initial position of the cart, the rail and the payload in a safe zone. The Go Home and Go To Center buttons are

applied to fulfil these tasks.

8. Mathematical model of the 3DCrane

The schematic diagram of the crane is given in Fig. 8.1.

There are five measured quantities:

• x_w (not marked in Fig. 8.1) denotes the distance of the rail with the cart from the center of the construction frame;
• y_w (not marked in Fig. 8.1) denotes the distance of the cart from the center of the rail;
• R denotes the length of the lift-line;

• denotes the angle between the y axis and the lift-line;
• denotes the angle between the negative direction on the z axis and the projection of the lift-line onto the xz plane.

Denote also:

mc -mass of the payload

mw -mass of the cart

ms -mass of the moving rail

xc,yc,zc -coordinates of the payload

S-reaction force in the lift-line acting on the cart

Fx -force driving the rail with cart

Fy -force driving the cart along the rail

FR -force controlling the length of the lift-line

Tx, Ty, TR -friction forces.

Detailed model is delivered with complete system

9. Description of the Crane3D class properties

The Crane3D is a MATLAB class, which gives the access to all the features of the RTDAC/PCI board equipped with the logic for the 3DCrane model. The RT-DAC/PCI board is an interface between the control software executed by a PC computer and the power-interface electronic of the 3DCrane model. The logic on the board contains the following blocks:

• incremental encoder registers – five 16-bit registers to measure the position of the incremental encoders. There are five identical encoders measuring five state quantities: two cart positions at the horizontal plane, the lift-line-length and two deviation angles of the payload;
• incremental encoder resets logic. The incremental encoders are able to generate different output waves when the encoder rotates clockwise and the counter clockwise. The encoders are not able to detect the reference (“zero”) position. To determine the “zero” position the incremental encoder registers can be set to zero from the computer program or an encoder register is reset when the corresponding limit switch to the encoder is reached;
• PWM generation block – generates three sets of signals. Each set contains the PWM output signal, the direction signal and the brake signal. The PWM prescaler determines the frequency of all the PWM waves. The PWM block logic can prevent the cart from motion outside the rail limits and the lift-line angles from lying outside the operating range. The operating ranges are detected twofold – by the limit switches and by three limit registers;
• power interface thermal flags – when the temperature of the power interface for the DC motors is too high the thermal flags can be used to disable the operation of the corresponding overheated DC motor.

All the parameters and measured variables from the RT-DAC/PCI board are accessible by appropriate methods of the Crane3D class.

The object of the Crane3D class is created by the command:

object_name = crane3d;

The get method is called to read a value of the property of the object:

property_value = get( object_name, ‘property_name’ );

The set method is called to set new value of the given property:

set( object_name, ‘property_name’, new_property_value );

The display method is applied to display the property values when the object_name is entered in the MATLAB command window.

This section describes all the properties of the Crane3D class. The description consists of the following fields:

Purpose	Provides short description of the property
Synopsis	Shows the format of the method calls
Description	Describes what the property does and the restrictions of is subjected to
Arguments	Describes arguments of the set method
See	Refers to other related properties
Examples	Provides examples how the property can be used

9.1. BaseAddress

Purpose: Read the base address of the RT-DAC/PCI board.

Synopsis: BaseAddress = get( cr3, ‘BaseAddress’ );

Description: The base address of RT-DAC/PCI board is determined by OS. Each Crane3D object has to know the base address of the board. When a Crane3D object is created the base address is detected automatically. The detection procedure detects the base address of the first RT-DAC/PCI board plugged into the PCI slots.

Example: Create the Crane3D object:

cr3 = crane3d;

Display its properties by typing the command:

cr3

>>Type: Crane3D Object >>BaseAddress: 528 >>Bitstream ver.: x33 >>Encoder: [ 65479 7661 20032 65533 65534 ][bit] >> [ -0.0022207[m] 0.29847[m] 0.38411[m] -0.004602[rad] -0.003068[rad] ] >>Z displacement: 0.32[m] >>PWM: [ -0.062561 0.031281 -1 ] >>PWMPrescaler: 60 >>RailLimit: [ 361 381 815 ]*64[bit] <--> [23104 24384 52160 ][bit] >> [ 0.90013 0.95 1.0002 ][m] >>RailLimitFlag: [ 1 1 1 ]>>RailLimitSwitch: [ 0 1 1 ] >>ResetSwitchFlag: [ 0 0 0 ] >>Therm: [1 1 1] >>ThermFlag: [ 1 1 1 ] >>Time: 1.041 [sec]

Read the base address:

BA = get( cr3, ‘BaseAddress’ );

9.2. BitstreamVersion

Purpose: Read the version of the logic design for the RT-DAC/PCI board.

Synopsis: Version = get( cr3, ‘BitstreamVersion’ );

Description: This property determines the version of the logic design of the RTDAC/PCI board. The 3DCrane models may vary and the detection of the logic design version makes it possible to check if the logic design is compatible with the physical model.

9.3. Encoder

Purpose: Read the incremental encoder registers.

Synopsis: enc = get( cr3, ‘Encoder’ );

Description: The property returns five digits. The first two measure the position of the cart. The third digit is used to measure the length of the lift-line and the last two measure the angles of the lift-line. The returned values can vary from 0 to 65535 (16-bit counters). When a register is reset the value is set to zero. When a rail limit flag is set it disables the movement outside the defined working range (rail limit). When a reset switch flag is set the encoder register is reset automatically when the appropriate switch is pressed. The incremental encoders generate 4096 or 2048 pulses per rotation. The values of the Encoder property should be converted into physical units.

See: ResetEncoder, RailLimit, RailLimitFlag, ResetSwitchFlag

9.4. PWM

Purpose: Set the parameters of the PWM waves.

Synopsis: PWM = get( cr3, ‘PWM’ ); set( cr3, ‘PWM’, NewPWM );

Description: The property determines the duty cycle and direction of the PWM waves for three DC motors. The first two DC motors control the position of the cart and the last motor controls the length of the lift-line. The PWM and NewPWM variables are 1x3 vectors. Each element of these vectors determines the parameters of the PWM wave for one DC motor. The values of the elements of these vectors can vary from –1.0 to 1.0. The value –1.0 means the maximum control in one direction, the value 0.0 means zero control and the value 1.0 means the maximum control in the opposite direction.

The PWM wave is not generated if:

• a rail limit flag is set and the cart or lift-line are going to operate outside the working range,
• a therm flag is set and the power amplifier is overheated.

See: RailLimit, RailLimitFlag, Therm, ThermFlag

Example: set( cr3, ‘PWM’, [ -0.3 0.0 1.0 ] );

9.5. PWMPrescaler

Purpose: Determine the frequency of the PWM waves.

Synopsis: Prescaler = get( cr3, ‘PWMPrescaler’ ); set( cr3, ‘PWMPrescaler’, NewPrescaler );

Description: The prescaler value can vary from 0 to 63. The 0 value generates the maximum PWM frequency. The value 63 generates the minimum frequency.

See: PWM

9.6. ResetEncoder

Purpose: Reset the encoder counters.

Synopsis: set( cr3, ‘ResetEncoder’, ResetFlags );

Description: The property is used to reset the encoder registers. The ResetFlags is a 1x5 vector. Each element of this vector is responsible for one encoder register. If the element is equal to 1 the appropriate register is set to zero. If the element is equal to 0 the appropriate register remains unchanged.

See: Encoder

Example: To reset the first and fourth encoder registers execute the command: set( cr3, ‘ResetEncoder’, [ 1 0 0 1 0 ] );

9.7. RailLimit

Purpose: Control the operating range of the 3D-crane system.

Synopsis: Limit = get( cr3, ‘RailLimit’ ); set( cr3, ‘RailLimit’, NewLimit );

Description: The Limit and NewLimit variables are 1x3 vectors. The elements of these vectors define the operating range of the cart and the maximum length of the lift-line. If a flag defined by the RailLimitFlag property is set the corresponding to it PWM wave stops when the corresponding to it encoder register exceeds the limit.

See: RailLimitFlag

9.8. RailLimitFlag

Purpose: Set range of limit flags.

Synopsis: LimitFlag = get( cr3, ‘RailLimitFlag’ ); set( cr3, ‘RailLimitFlag’, NewLimitFlag );

Description: The RailLimitFlags is a 1x3 vector. The first two elements control the operating range of the cart. The last element controls the maximum length of the lift-line. If the flag is set to 1 and the encoder register exceeds the range the DC motor corresponding to it stops. If the flag is set to 0 the motion continues in spite of the range limit exceeded in the encoder register.

See: RailLimit, RailLimitSwitch

9.9. RailLimitSwitch

Purpose: Read the state of limit switches. Synopsis: LimitSwitch = get( cr3, ‘RailLimitSwitch’ ); Description: Reads the state of three limit switches. Returns a 1x3 vector. If an element of

this vector is equal to 0 it means that the switch has been pressed.

See: RailLimit, RailLimitFlag

9.10. ResetSwitchFlag

Purpose: Control the auto-reset of the encoder registers.

Synopsis: ResetSwitchFlag = get( cr3, ‘ResetSwitchtFlag’ ); set( cr3, ‘ResetSwitchFlag’, ResetSwitchFlag );

Description: The ResetSwitchFlag and NewResetSwitchFlag are 1x3 vectors. If an element of these vectors is equal to 1 the corresponding to it encoder register is automatically reset in the case when the corresponding to it limit switch is pressed.

See: ResetEncoder, RailLimitSwitch

9.11. Therm

Purpose: Read thermal flags of the power amplifiers. Synopsis: Therm = get( cr3, ‘Therm’ ); Description: Returns three thermal flags of three power amplifiers. When the temperature

of a power amplifier is too high the appropriate flag is set to x.

See: ThermFlag

9.12. ThermFlag

Purpose: Control an automatic power down of the power amplifiers.

Synopsis: ThermFlag = get( cr3, ‘ThermFlag’ ); set( cr3, ‘ThermFlag’, NewThermFlag );

Description: The ThermFlag and NewThermFlag are 1x3 vectors. If an element of these vectors is equal to 1 the DC motor corresponding to it is not excited by the PWM wave when it is overheated.

See: Therm

9.13. Time

Purpose: Return time information.

Synopsis: T = get( cr3, ‘Time’ );

Description: The Crane3D object contains the time counter. When a Crane3D object is created the time counter is set to zero. Each reference to the Time property updates its value. The value is equal to the number of milliseconds past since the object was created.

9.14. Quick reference table

Property Name	Description
BitstreamVersion	Read the version of the logic design for the RT-DAC/PCI board
Encoder	Read the incremental encoder registers
PWM	Set the parameters of the PWM waves
PWMPrescaler	Determine the frequency of the PWM waves
ResetEncoder	Reset the encoder counters
RailLimit	Control the operating range of the 3DCrane system
RailLimitFlag	Set the range limit flags
RailLimitSwitch	Read the state of the limit switches
ResetSwitchFlag	Control the auto-reset of the encoder registers
Therm	Read the thermal flags of the power amplifiers
ThermFlag	Control the automatic power down of the power amplifiers
Time	Return time information

10. How to fulfil the compilation settings page

In Fig. 10.1, Fig. 10.2 and Fig. 10.3 the different Simulation Parameters pages are shown. Having the MATLAB version and the compiler version the user has to choose the appropriate Simulation Parameters page version.