This tutorial is delivered subject to the following conditions and restrictions:
This tutorial contains proprietary information belonging to Elmo Motion Control Ltd.
The text and graphics included in this manual are for the purpose of illustration and
reference only. The specifications on which they are based are subject to change
without notice.
Elmo Motion Control and the Elmo Motion Control logo are trademarks of Elmo
Motion Control Ltd.
Information in this document is subject to change without notice.
Appendix C: Intersection point of two lines defined by the end points ....................... C-1
Appendix D: Circle – line intersection points ...................................................................D-1
2-6
2-12
2-20
2-22
2-24
2-25
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
Chapter 1: General Description
1.1 Introduction
The Motion Library (ML) produces trajectories based on the PVT mechanism. It implements a set
of functions that calculate trajectories as PVT tables for the vector motion. As a result of a call to the
Motion Library functions, the user gets a PVT table for the requested trajectory. It supports two
and three-dimensional vector motion.
A PVT table is a two or three-dimensional sequence of PVT points.
Each PVT point is defined by:
• position value
• velocity for this position
1
•time interval that is necessary to arrive from the current position to the position defined by
the next PVT point
It supports
1. Single shape trajectories:
line (2D,3D)
circle (2D)
2. Trajectory built from an arbitrary set of pointes interpolated by the cubic spline (2D,3D)
3. Polyline trajectory that can include a number of single shapes:
line segments (2D,3D)
circle arc segments (2D)
spline points (2D,3D)
Inside polyline transition from one shape to another can be executed with a non-zero velocity. In
this case, an additional element – switch circle arc-- is inserted between two shapes.
In the case of two-dimensional vector motion, switch arcs can be built for the line-line, line-circle,
circle-line and circle-circle intersections. In the case of a three-dimensional polyline, switch arcs can
be built for the line-line intersection.
1.2 Vector properties
Geometry of trajectory is defined by the set of vector functions such as circle() or line(). The
Velocity profile is also influenced by the set of the following parameters (vector properties):
maximum vector acceleration/deceleration (vac/vdc)
maximum vector velocity (vsp)
end velocity (vse)
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
general trajectory time (vtt)
switch arc definitions (vsc, vsr, vsd)
admissible velocity and position errors definitions (vpe,vve)
PVT step low and high limits (VNT,VXT )
All of the vector’s properties can be set in a user program or by the Command Interpreter.
Syntax of a property:
Vector_name.property
Examples:
v1.vsp - defines maximum vector velocity
v1.vtt - defines trajectory time
v1.vsc - defines smooth type from one shape to another
2
(1 – minimal radius switch arc, 2 – fixed radius switch arc, 3 – switch with a fixed distance from
the intersection point).
Single shape trajectories can be executed in one of three modes pre-defined by the value of the
input parameter vum: 1 – max velocity, 2 – fixed time, 3 – fixed velocity.
In the maximum velocity mode, velocity defined by the parameter vsp is considered a limiting
value that cannot be exceeded. If a trajectory is not long enough to achieve such a value, then a
trajectory with a triangle velocity profile is built and some maximum vector velocity
V
max
< vsp
is achieved at one point.
The fixed velocity mode (vum=3) is used if the user is interested in building a trajectory with a
trapezium velocity profile – the main part of the trajectory (with the exception of possible
acceleration/deceleration at the initial and final parts of the trajectory) is executed with a velocity
equal to vsp. If a trajectory is not long enough to reach velocity vsp with the given vector
acceleration /deceleration (input parameters vac/vdc), the trajectory is not built and the user
receives an error message.
In the fixed time mode (vum = 2) the user must define parameter vtt – time in milliseconds for the
trajectory execution. The Motion Library chooses a velocity profile that satisfies parameter vtt. If a
trajectory with the given length, maximum velocity vsp and vector acceleration/deceleration
cannot be executed within time vtt trajectory is not built and the user receives an error message.
The user can set values for the maximum PVT step in milliseconds – parameter vxt and for the
minimal PVT step – parameter vnt ≥ 1msec. In this case, the main part of the trajectory will be
executed with the PVT step
ΔT = 0.5(vxt + vnt).
For the switch arc, connecting two shapes can be chosen from one of the three possible modes predefined by the input parameter vsc: 0 – no switch arc to be built, 1 – switch arc with the minimal
possible radius, 2 – switch arc with radius pre-defined by the user, 3 – user defined distance from
the intersection point (for the line-line or circle-line intersections).
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
1.3 Trajectory generation
1.3.1 Line
Target position for a line is defined by the parameters of the function line():
Two-dimensional line
V1.line(x,y) – produces a line trajectory from the current position to the point (x,y), where x and
y integer values in counts.
Three-dimensional line
V1.line(x,y,z) – produces line trajectory from the current position to the point (x,y,z), where x,y
and z - integer values in counts.
1.3.2 Circle
Radius, initial and sweep angles for a circle must be defined as parameters of a function circle():
V1.circle(radius, init_angle,sweep_angle), where init_angle and sweep_angle must be set in
degrees (float), radius in counts (integer).
Example (Motion Mathematic Lib Samples\ Vector_2D \CircleArc – www.elmomc.com)
v1.vac = 28000000 //max acceleration
3
v1.vdc = 28000000 //max deceleration
v1.vum = 1 //build trajectory in max. velocity mode
v1.vsp = 250000 //maximum velocity
v1.vse = 0 //end velocity
v1.circle(100000,45,-270) //build circle arc trajectory
v1.bg // start motion
while (a1.ms==2)||(a2.ms==2) //wait until both axes have stopped
wait(10)
end while
1.3.3 Spline
A spline gives the possibility to move a smooth curve through an arbitrary set of points that do not
necessary belong to a particular geometric shape as a circle, ellipse or a line.
The spline that is supported by the Motion Library is an interpolation cubic spline. All the points
Po,P1,...,P
points
given by the user belong to the spline curve. Between each pair of the neighboring
n
(Pi,P
), cubic spline is defined by a third-order polynomial.
i+1
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
Other popular types of splines like Bezier curves, B- splines or NURBS are usually not
interpolation but smoothing splines. The spline curve does not move through the given points but
near them.
So cubic splines are piecewise polynomial (built of cubic polynomials for each segment [i,i+1]) and
produce a curve with continuous first and second derivatives at the internal control points
…,
P
that, in case of motion control, means continuity of the velocity and acceleration. Denote a
n-1
cubic spline polynomial for the segment [i,i+1] as
and S
′′(ti) = S′′
i
), i = 1,2,…,n-1.
i+1(ti
Si(t) than Si(ti) = S
), Si′(ti) = S
i+1(ti
P
i+1
The spline trajectory is executed in the maximum velocity mode vum = 1. Input parameters that
define kinematics of the trajectory are maximum velocity – parameter vsp, vector acceleration –
parameter vac and vector deceleration – parameter vdc.
The Motion Library user can define points for the spline interpolation applying the following
function calls:
vector_name.splines(trj_name) - starts a sequence of points to be interpolated. The PVT table is
saved in a file named trj_name. The function parameter trj_name can be missed. In this case, the
trajectory is saved in a temporary file named vector_name.trj (where vector_name – name
defined in a resource file).
To interpolate two-dimensional points, use a function call
, P2,
1
′(ti)
4
vector_name.splinep(int PosX, int PosY) ) – adds interpolation point with coordinates (PosX,
PosY).
In three-dimensional space
vector_name.splinep(int PosX, int PosY, int PosZ) ) – adds 3D interpolation point with
coordinates (PosX, PosY, PosZ).
vector_name.splinee(parameter) - ends the spline trajectory sequence.
– If parameter = 0 the standard PVT table that in each line contains PVT points for the X and Y
axes (for 2D spline) or PVT points for X, Y and Z axes (for 3D spline) is built.
– If parameter ≠ 0 three tables for the axis X, axis Y and for the gear are built. The table for the
gear contains PVT points with the position equal to the distance along the spline from the
2
initial spline position, vector velocity V = [V
2]1/2
+ V
x
for this position and a standard time
y
step (in 3D case four tables for X,Y, Z and gear are built).
Inside the spline operator parenthesis splines(trj_name) and vector_name.splinee(parameter) can be added operators for the position calculation (for
instance ellipse points X = X
+ acos(t), Y = Yc + bsin(t)).
c
The Motion Library generates a trajectory by the cubic spline interpolation
Important note: Current position is not automatically added to the sequence of spline points.
Homing must be done to the first spline point.
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
1.3.3.1 Examples for the two-dimensional spline interpolation
Example Example (Motion Mathematic Lib Samples\ Vector_2D \ Spline_Ellipse –
www.elmomc.com)
Ellipse trajectory (2D spline interpolation)
v1.vum=1 //build trajectory in max velocity mode
v1.vac = 28000000 //max acceleration
v1.vdc = 28000000 //max deceleration
v1.vsp = 50000//max. velocity
v1.vse = 0 //end velocity
pi = 3.14159265358979
5
a = 100000
//ellipse axis a
b = 50000 //ellipse axis b
Xc = 0 //ellipse center coordinateby X
Yc = 0 //ellipse center coordinateby Y
v1.splines()//start spline trajectory
for teta = 0:pi/18:2*pi
x = Xc + a*cos(teta)
y = Yc + b*sin(teta)
v1.splinep(x,y)
// add point to the spline trajector y
end for
v1.splinee(0) // end spline trajectory
v1.bg //start motion
After homing drives must at the first point of the sequence.
Example Example (Motion Mathematic Lib Samples\ Vector_2D \ Lissajous curves –
www.elmomc.com)
v1.vac = 28000000 //max vector acceleration
v1.vdc = 28000000 //max vector deceleration
v1.vsp = 100000 //set max. velocity
v1.vse = 0 //set end velocity
v1.splines() // start spline sequence
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
for t = 0:pi/72:2*pi
x = R*cos(3*t)
y = R*sin(5*t)
v1.splinep(x,y) // add spline point
end for
v1.splinee(0) // end spline sequence
v1.bg //start motion
while (a1.ms==2)||(a2.ms==2) //wait until both axes have stopped
wait(10)
end while
6
Figure 1-1: Recording of the spline trajectory (Lissajous curves)
1.3.3.2 Examples of three-dimensional spline interpolatio n
For 3D vector motion, there must be a defined resource file with a vector built from three axes.
In the Elmo Studio it can be defined as shown in the picture below.
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
7
Figure 1-2: Resources for the 3D vector
Example (Motion Mathematic Lib Samples\ Vector_3D \ Spline_3D – www.elmomc.com)
A spline curve throws a number of arbitrary points
SetAxisStartPos(a1, 0) //set coordinate x to 0
SetAxisStartPos(a2, 0) //set coordinate y to 0
SetAxisStartPos(a3, 0) //set coordinate y to 0
v2.vsp = 50000
v2.vse=0
v2.splines() // start spline sequence
v2.splinep(0, 0, 0) // add spline 3D point
v2.splinep(50000, 100000, 150000) // add spline 3D point
v2.splinep(100000, 50000, 100000) // add spline 3D point
v2.splinep(200000, 150000, 50000) //add spline 3D point
v2.splinee(0) // end spline sequence
Three-dimensional picture can be drawn in Matlab with the use of the following Matlaboperators
%d %d %d ', -1) where 'D:\Dir_22_01\trj_file – full path to the PVT table file.
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
For this operator to work properly, the first line of the PVT table containing a text header must be
removed.
plot3(posX,posY,posZ)
axis square; grid on
8
Figure 1-3: Three-dimensional picture corresponding to the calculated
PVT table (drawn in Matlab)
Results of the recording
Figure 1-4: Projection on the XY plane
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
Figure 1-5: Projection on the XZ plane
9
Example (Motion Mathematic Lib Samples\ Vector_3D \ Helix – www.elmomc.com)
Helix curve built with the use of the spline interpolation.
SetAxisStartPos(a1, 50000) //set coordinate x to 0
SetAxisStartPos(a2, 0) //set coordinate y to 0
SetAxisStartPos(a3, 0) //set coordinate y to 0
v2.vsp = 50000
v2.vse=0
alpha = 0 //start angle degrees
beta = 3600 // sweep angle degrees
R = 50000
H = 250000 // height
X = 50000 // start pos x
Y = 0 // start pos y
Z = 0 // start pos z
n = 120 // num points
Teta = pi*(alpha/180) //radian
dTeta = (pi*(beta/180))/n // teta increment for one step
dZ = H/n //z increment for one step
Xc = X - R*cos(Teta) // X coordinate of the helix axis
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
Yc = Y - R*sin(Teta) // X coordinate of the helix axis
v2.splines() // start spline sequence
for i=0:1:n
v2.splinep(X,Y,Z) // add spline 3D point
Teta = Teta + dTeta // calc teta for the next point
X = Xc + R*cos(Teta) // calc X coordinate for the next point
Y = Yc + R*sin(Teta) // calc Y coordinate for the next point
Z = Z + dZ // calc Z coordinate for the next point
end for
v2.splinee(0) // end spline sequence
v2.bg // begin motion
Figure 1-6: Helix three-dimensional picture for the calculated PVT table drawn in MATLAB
10
1.3.4 Polyline
To build a polyline, the Maestro user program applies the following calls to the motion library
functions:
vector_name.starts(trj_name) – starts the polyline trajectory sequence with saving the PVT table
built by the Motion Library in a file named trj_name. Parameter trj_name can be missed – in
this case trajectory is saved in a temporary file named vector_name.trj.
vector_name.ends() - ends the polyline trajectory sequence.
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
Inside the polyline operator parenthesis vector_name.starts(trj_name) and vector_name.ends() can
be added function calls – addline(), addcircle(), addsplinep() and adddwell() to define polyline
segments.
For the 2D polyline
vector_name.addline (int PosX, int PosY) – adds a line segment
PosX, PosY - destination position of the linear segment (counts)
vector_name.addcircle(int Radius, float StartAngle, float SweepAngle) – adds circle arc
segment
Radius - radius of the circle segment (counts)
start_angle - start angle of the circle segment (degrees)
sweep_angle - sweep angle of the circle segment (degrees)
vector_name.addsplinep(int x, int y) - adds two-dimensional spline point
11
Important note: The user should take into account that the last point of the previous segment or the
first point of the trajectory is automatically added to the spline. The minimal number of the
addsplinep() operators that define the same spline segment inside the polyline must be great equal
2. This requirement is valid for every spline segment inside the polyline – not only for the first one.
For the 3D polyline
vector_name.addline (int PosX, int PosY, int PosZ) – adds a line segment
PosX, PosY, PosZ - destination position of the linear segment (counts).
vector_name.addsplinep(int x, int y, int z) - adds three-dimensional spline point
As in a two-dimensional case, the last point of the previous segment is automatically added to
the spline segment and the number of points defining the spline segment cannot be less than 2.
For 2D and 3D polyline
vector_name.adddwell(delay_time) – adding delay (station) between two segments
delay_time - delay value in millisecond
Smooth transition from one curve to another inside polyline.
There are four modes that define transition from one shape to another that are defined by the
parameter (vector property) vsc:
1. vsc = 0 - switch arc is not built
2. vsc = 1 – ML builds switch arc with switch radius minimally radius that satisfies kinematics
constraint r > (vse)
vse – parameter that defines end velocity on the segment preceding switch arc
vac – parameter that defines maximum vector acceleration
vae – parameter that defines admissible error for the vector acceleration
2
/[vac*vae] where
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
3. vsc = 2 – ML builds switch arc with the switch radius vsr
(this parameter must be set by the user).
4. vsc = 3 - ML builds a switch arc with the switch radius implicitly pre-defined via parameter
vsd (distance along the line from the intersection point). Parameter vsd must be set by the
user.
For vsc = 2 and vsc = 3, the user can check if the values of the parameters vsr and vsd satisfy
geometric constraints. Such a check can be done with the use of algorithms described in chapter 2 of
this document.
Switch arc building is also influenced by the previous segment end velocity defined by the parameter
(vector property) vse.
1.3.4.1 Examples for the two-dimensional polyline
Example (Motion Mathematic Lib Samples\ Vector_2D \ LineCircle – www.elmomc.com)
12
v1.vac = 28000000 //max vector acceleration
v1.vdc = 28000000 // max vector deceleration
v1.vum = 1 // build trajectory in max velocity mode
v1.starts() // begin polyline trajectory
v1.vsp = 50000 // max velocity for the line segment
v1.vse = 50000 // end velocity
v1.addline(100000, 100000) // request to add line shape
v1.vse = 0 // end velocity for the circle segment
v1.vsc = 2 // smooth intersection with fixed switch radius
v1.vsr = 10000 // switch radius
v1.addcircle(50000,225,180) //request to add circle arc shape
v1.ends() // ends polyline trajectory
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
13
Figure 1-7: Recording of the polyline trajectory
Any trajectory generated by the Motion Library (single shape or polyline) can be rotated relative to
init point due to vector property vra – rotation angle in degrees.
Example (Motion Mathematic Lib Samples\ Vector_2D \ LineCircleRotated –
www.elmomc.com)
// The same polyline rotated at –90 degrees relative to init point
v1.vac = 28000000 //max vector acceleration
v1.vdc = 28000000 // max vector deceleration
v1.vum = 1 // build trajectory in max velocity mode
v1.vra = -90 // rotate spline 90 degrees relative to init point
v1.starts() // begin polyline trajectory
v1.vsc = 2 // smooth intersection with fixed switch radius
v1.vsp = 50000 // max velocity for the line segment
v1.vse = 50000// end velocity
v1.addline(100000, 100000)// request to add line shape
v1.vsp = 50000// maximum velocity for the circle segment
v1.vse = 0// end velocity for the circle segment
v1.vsr = 10000 // switch radius
v1.addcircle(50000,225,180)//request to add circle arc shape
v1.ends()// end polyline trajectory
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
14
Figure 1-8: Recording of the rotated polyline
1.3.4.2 Examples for the three-dimensional polyline
Example (Motion Mathematic Lib Samples\ Vector_3D \ Rectangle – www.elmomc.com)
Three-dimensional rectangle
SetAxisStartPos(a1, 0) //set coordinate x to 0
SetAxisStartPos(a2, 0) //set coordinate y to 0
SetAxisStartPos(a3, 0) //set coordinate y to 0
v2.vsc=2
v2.vsr=12000
v2.vsp = 70000 //max. vector velocity
v2.vse = 70000
v2.starts()
v2.addline(50000, 50000, 0) //create line from current point to coordinate
v2.addline(50000, 50000, 50000)
v2.addline(0, 0, 50000)
v2.vse = 0
v2.addline(0, 0, 0)
v2.ends()
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
Figure 1-9: Three-dimensional polygon drawn in Matlab
15
Results of the recording
Figure 1-10: Projection on the XZ plane
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
16
Figure 1-11: Projection on the YZ plane
1.4 Transition to a new trajectory with a non-zero velocity
If a transition from one trajectory to another (for instance from a line to a circle) must be executed
with a velocity not equal to zero at the switch point, the Motion Library builds a switch curve to
achieve smooth modification of the velocity. Such a curve is implemented as a circle arc.
As a geometrical object switch arc is completely defined by:
• radius
• coordinates of the two limit points (
where (
(
•center coordinates (X
The radius
r
X
X
last
first
, Y
) – last point on the first shape
last
, Y
) – first point on the second shape
first
)
o,Yo
r of the switch arc can be:
X
last
, Y
) and (X
last
first
, Y
first
)
1. Explicitly pre-defined by the user (vsc = 2, vsr defined).
In this case, it must obey the following restriction:
r ≥ (V
where
AC
) 2/AC
end
V
- end velocity at the switch point,
end
v -
v
vector acceleration.
(1-1)
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
17
In fact, the value defined as r ≥ (vse)
the calculations.
Implicitly pre-defined by the user via smooth distance d along the line from the intersection
2.
point (vsc = 3, vsd defined). This mode can be implemented to the line – line, circle – line
and line – circle trajectory intersections.
3. Calculated as a minimal possible for the given end velocity V
AC
Regardless of the
switch arc is considered to be uniform with the constant tangent velocity
angle velocity
(vsc = 1).
v
r definition (pre-defined by the user or calculated by (1-1)) movement along the
2
/(vae*vac )
(by default vae = 0.9) must be used in
and vector acceleration
end
V = V
andconstant
end
ω = V/r (1-2)
The intersection geometry imposes constraints on the switch arc radius. So the switch radius in use
r must satisfy
(V
) 2/AC
end
< r < r
v
max
(1-3)
Chapter 2 will consider all cases of the two shapes intersections and methods for the calculation of
the switch
As a base value for the switch velocity is taken the preceding segment end velocity V
by the parameter vse. This value is considered as a limiting parameter that cannot be exceeded but
can be decreased. It’s also valid in case that polyline segments (preceding switch arc and the
following) are executed in the fixed velocity mode (vum = 3).
In switch mode vsc = 1, the initial value of a switch velocity equal vse and can be decreased to
build a switch arc trajectory equal to the integer number of PVT steps or milliseconds.
In switch mode vsc = 1, the radius of the switch arc is calculated as a minimal possible for the
intersection geometry and given vector acceleration/deceleration (input parameters vac/vdc)
meaning that the calculated value satisfies
account the requirement to build switch arc trajectory equal to an integer number of PVT steps. The
Motion Library is trying to build switch arc trajectory with velocity as close to the value given by
the parameter vse for the preceding segment as possible. The switch arc (or two arcs on both ends
of the segment) can take up almost all segment length that sometimes makes trajectory calculation
impossible.
As an example consider the following: segment initial velocity equal
radius limit valuer
max.
defined
end
(1-3). While the switch arc calculation is also taken into
Vo, end velocity V
and
e
min(V
(where ΔL – the length of the segment truncated by switch arcs, ΔT – standardPVT step). When
defining switch radius (input parameter vsr) for vsc = 2 mode or end velocity (input parameter vse)
for vsc = 1 mode, the user must take into account that it can significantly influences the whole
trajectory and in fact replaces the main part of a particular segment by switch arcs.
)ΔT > ΔL (1-4)
o,Ve
Maestro Motion Library Tutorial
MAN-INTUG (Ver. 1.7)
Input parameters and intersection geometry define the influence of a switch arc on a trajectory. The
main cases of shapes intersection are considered below. Here as an example to consider two lines
intersection. If an angle between two lines is small, even a switch arc with a small radius can
significantly change initial trajectory while an arc with the same radius can be insignificant for lines
with intersection angle close to
180
o
.
In addition to geometric constraints, the Motion Library imposes limitations on the switch arc
length. Each switch arc should not exceed 50% of the segment length. If there are two switch arcs
adjacent to some polyline segment, then both arcs should not take more than 80% of its initial
length.
18
Motion Library TutorialSwitch Radius Calculation
MAN-MLT (Ver 2.0)
Chapter 2: Switch Radius Calculation
2.1 Line – line intersection
2-1
If a trajectory contains a switch from line L
of the vector velocity cannot be changed at the one intersection point. To implement such a
switch, insert into a trajectory an additional element – circle arc is inserted into a trajectory
(see-Figure 2-1).
The switch arc radius must satisfy (1-1).
to line L
1
with non-zero velocity, the direction
2
Figure 2-1
In the case of a line-line intersection, parameters
equation
r and d are connected by the simple
r = d*tg(γ/2) (2.1-1
where γ = π – α (α - angle between vectors L
and L2) so the pre-defined parameter
1
vsd = d must satisfy
vsd ≥ (V
If ΔL1 is the length of the line L1 and ΔL2 is the length of the line L2, then there is an evident
geometric constraint for the switch radius r
r
≤ min(ΔL1, ΔL
max
(2.1-3)
In fact, due to additional limitations (50% of the segment length) used in ML, the following
should be used
)2/[ACv tg(γ/2)]
end
)*tg(γ/2)
2
(2.1-2)
Loading...
+ 50 hidden pages
You need points to download manuals.
1 point = 1 manual.
You can buy points or you can get point for every manual you upload.