The friction model is implemented in a "clean" way by state events and leads to continuous/discrete systems of equations which have to be solved by appropriate numerical methods. The method is described in:

Otter M., Elmqvist H., and Mattsson S.E. (1999):

Hybrid Modeling in Modelica based on the Synchronous Data Flow Principle. CACSD'99, Aug. 22.-26, Hawaii.

More precise friction models take into account the elasticity of the material when the two elements are "stuck", as well as other effects, like hysteresis. This has the advantage that the friction element can be completely described by a differential equation without events. The drawback is that the system becomes stiff (about 10-20 times slower simulation) and that more material constants have to be supplied which requires more sophisticated identification. For more details, see the following references, especially (Armstrong and Canudas de Witt 1996):

Armstrong B. (1991):

Control of Machines with Friction. Kluwer Academic Press, Boston MA.

Armstrong B., and Canudas de Wit C. (1996):

Friction Modeling and Compensation. The Control Handbook, edited by W.S.Levine, CRC Press, pp. 1369-1382.

Canudas de Wit C., Olsson H., Astroem K.J., and Lischinsky P. (1995):

A new model for control of systems with friction. IEEE Transactions on Automatic Control, Vol. 40, No. 3, pp. 419-425.

Release Notes:

• First Version from December 7, 1999 by P. Beater (based on Rotational.BearingFriction)
• July 14, 2001 by P. Beater, assert on initialization added, diagram modified
• October 11, 2001, by Hans Olsson, Dynasim, modified assert to handle start at stops, modified event logic such if you have friction parameters equal to zero you do not get events between the stops.
• June 10, 2002 by P. Beater, StateSelect.always for variables s and v (instead of fixed=true).

Parameters

Name	Default	Description
L	0	length of component from left flange to right flange (= flange_b.s - flange_a.s) [m]
smax	25	right stop for (right end of) sliding mass [m]
smin	-25	left stop for (left end of) sliding mass [m]
v_small	1e-3	Relative velocity near to zero (see model info text) [m/s]
m	1	mass [kg]
F_prop	1	velocity dependent friction [N/ (m/s)]
F_Coulomb	5	constant friction: Coulomb force [N]
F_Stribeck	10	Stribeck effect [N]
fexp	2	exponential decay [1/ (m/s)]

Modelica definition

model Stop "Sliding mass with hard stop and Stribeck friction" 
  extends Modelica.Mechanics.Translational.Interfaces.FrictionBase(s(stateSelect=
          StateSelect.always));
  Modelica.SIunits.Velocity v(stateSelect=StateSelect.always) 
    "Absolute velocity of flange_a and flange_b";
  Modelica.SIunits.Acceleration a 
    "Absolute acceleration of flange_a and flange_b";
  parameter Modelica.SIunits.Mass m=1 "mass";
  
  parameter Real F_prop(
    final unit="N/ (m/s)", 
    final min=0) = 1 "velocity dependent friction";
  parameter Modelica.SIunits.Force F_Coulomb=5 "constant friction: Coulomb force";
  parameter Modelica.SIunits.Force F_Stribeck=10 "Stribeck effect";
  parameter Real fexp(
    final unit="1/ (m/s)", 
    final min=0) = 2 "exponential decay";
  
equation 
  
  // Constant auxiliary variables
  f0 = (F_Coulomb + F_Stribeck);
  f0_max = f0*1.001;
  free = f0 <= 0 and F_prop <= 0 and s > smin + L/2 and s < smax - L/2;
  
  // Velocity and acceleration of flanges
  v = der(s);
  a = der(v);
  v_relfric = v;
  a_relfric = a;
  
  // Equilibrium of forces
  0 = flange_a.f + flange_b.f - f - m*der(v);
  
  // Friction force
  f = if locked then sa else if free then 0 else (if startForward then F_prop*v
     + F_Coulomb + F_Stribeck else if startBackward then F_prop*v - F_Coulomb
     - F_Stribeck else if pre(mode) == Forward then F_prop*v + F_Coulomb + 
    F_Stribeck*exp(-fexp*abs(v)) else F_prop*v - F_Coulomb - F_Stribeck*exp(-
    fexp*abs(v)));
  
  
    // Define events for hard stops and reinitiliaze the state variables velocity v and position s
algorithm 
  when (initial()) then
    assert(s > smin + L/2 or s >= smin + L/2 and v >= 0, 
      "Error in initialization of hard stop. (s - L/2) must be >= smin ");
    assert(s < smax - L/2 or s <= smax - L/2 and v <= 0, 
      "Error in initialization of hard stop. (s + L/2) must be <= smax ");
  end when;
  
  when not (s < smax - L/2) then
    reinit(s, smax - L/2);
    if (not initial() or v > 0) then
      reinit(v, 0);
    end if;
  end when;
  
  when not (s > smin + L/2) then
    reinit(s, smin + L/2);
    if (not initial() or v < 0) then
      reinit(v, 0);
    end if;
  end when;
end Stop;

Modelica.Mechanics.Translational.Rod

Information

Rod without inertia and two rigidly connected flanges.

Release Notes:

• First Version from August 26, 1999 by P. Beater

Parameters

Name	Default	Description
L	0	length of component from left flange to right flange (= flange_b.s - flange_a.s) [m]

Modelica definition

model Rod "Rod without inertia" 
  extends Interfaces.Rigid;
  
equation 
  0 = flange_a.f + flange_b.f;
end Rod;

Modelica.Mechanics.Translational.Spring

Information

A linear 1D translational spring. The component can be connected either between two sliding masses, or between a sliding mass and the housing (components FixedLeft, FixedRight), to describe a coupling of the slidin mass with the housing via a spring.

Release Notes:

• First Version from August 26, 1999 by P. Beater (based on Rotational.Spring)

Parameters

Name	Default	Description
s_rel0	0	unstretched spring length [m]
c	1	spring constant [N/m]

Modelica definition

model Spring "Linear 1D translational spring" 
  extends Interfaces.Compliant;
  parameter SI.Distance s_rel0=0 "unstretched spring length";
  parameter Real c(
    final unit="N/m", 
    final min=0) = 1 "spring constant ";
  
equation 
  f = c*(s_rel - s_rel0);
end Spring;

Modelica.Mechanics.Translational.Damper

Information

Linear, velocity dependent damper element. It can be either connected between a sliding mass and the housing (FixedLeft, FixedRight elements), or between two sliding masses.

Release Notes:

• First Version from August 26, 1999 by P. Beater (based on Rotational.Damper)

Parameters

Name	Default	Description
d	0	damping constant [N/ (m/s)] [N/ (m/s)]

Modelica definition

model Damper "Linear 1D translational damper" 
  extends Interfaces.Compliant;
  parameter Real d(
    final unit="N/ (m/s)", 
    final min=0) = 0 "damping constant [N/ (m/s)]";
  SI.Velocity v_rel "relative velocity between flange L and R";
equation 
  v_rel = der(s_rel);
  f = d*v_rel;
end Damper;

Modelica.Mechanics.Translational.SpringDamper

Information

A spring and damper element connected in parallel. The component can be connected either between two sliding masses to describe the elasticity and damping, or between a sliding mass and the housing (FixedLeft, FixedRight elements), to describe a coupling of the sliding mass with the housing via a spring/damper.

Release Notes:

• First Version from August 26, 1999 by P. Beater (based on Rotational.SpringDamper)

Parameters

Name	Default	Description
s_rel0	0	unstretched spring length [m]
c	1	spring constant [N/m]
d	1	damping constant [N/(m/s)]

Modelica definition

model SpringDamper 
  "Linear 1D translational spring and damper in parallel" 
  extends Interfaces.Compliant;
  parameter SI.Position s_rel0=0 "unstretched spring length";
  parameter Real c(
    final unit="N/m", 
    final min=0) = 1 "spring constant";
  parameter Real d(
    final unit="N/(m/s)", 
    final min=0) = 1 "damping constant";
  SI.Velocity v_rel "relative velocity between flange L and R";
  
equation 
  v_rel = der(s_rel);
  f = c*(s_rel - s_rel0) + d*v_rel;
end SpringDamper;

Modelica.Mechanics.Translational.ElastoGap

Information

A linear translational spring damper combination that can lift off. The component can be connected between between a sliding mass and the housing (components FixedLeft, FixedRight), to describe the contact of a sliding mass with the housing.

Release Notes:

• First Version from August 26, 1999 by P. Beater

Parameters

Name	Default	Description
s_rel0	0	unstretched spring length [m]
c	1	spring constant [N/m]
d	1	damping constant [N/ (m/s)]

Modelica definition

model ElastoGap "1D translational spring damper combination with gap"
   
  extends Interfaces.Compliant;
  parameter SI.Position s_rel0=0 "unstretched spring length";
  parameter Real c(
    final unit="N/m", 
    final min=0) = 1 "spring constant";
  parameter Real d(
    final unit="N/ (m/s)", 
    final min=0) = 1 "damping constant";
  SI.Velocity v_rel "relative velocity between flange L and R";
  Boolean Contact "false, if s_rel > l ";
  
equation 
  
  v_rel = der(s_rel);
  Contact = s_rel < s_rel0;
  f = if Contact then (c*(s_rel - s_rel0) + d*v_rel) else 0;
end ElastoGap;

Modelica.Mechanics.Translational.Position

Information

The input signal inPort.signal[1] defines the reference position s_ref in [m]. Flange flange_b is forced to move according to this reference motion. According to parameter exact (default = false), this is done in the following way:

1. exact=true
   The reference position is treated exactly. This is only possible, if the input signal is defined by an analytical function which can be differentiated at least twice. If this prerequisite is fulfilled, the Modelica translator will differentiate the input signal twice in order to compute the reference acceleration of the flange.
2. exact=false
   The reference position is filtered and the second derivative of the filtered curve is used to compute the reference acceleration of the flange. This second derivative is not computed by numerical differentiation but by an appropriate realization of the filter. For filtering, a second order Bessel filter is used. The critical frequency (also called cut-off frequency) of the filter is defined via parameter f_crit in [Hz]. This value should be selected in such a way that it is higher as the essential low frequencies in the signal.

The input signal can be provided from one of the signal generator blocks of the block library Modelica.Blocks.Sources.

Release Notes:

• June 19, 2000 by Martin Otter.
  Realized.

Parameters

Name	Default	Description
exact	false	true/false exact treatment/filtering the input signal
f_crit	50	if exact=false, critical frequency of filter to filter input signal [Hz]

Modelica definition

model Position 
  "Forced movement of a flange according to a reference position" 
  parameter Boolean exact=false 
    "true/false exact treatment/filtering the input signal";
  parameter SI.Frequency f_crit=50 
    "if exact=false, critical frequency of filter to filter input signal";
  
  output SI.Position s_ref "reference position defined with the input signal";
  output SI.Position s "absolute position of flange_b";
  output SI.Velocity v "absolute velocity of flange_b";
  output SI.Acceleration a "absolute acceleration of flange_b";
protected 
  parameter Real w_crit=2*Modelica.Constants.pi*f_crit 
    "critical frequency in [1/s]";
  constant Real af=1.3617 "s coefficient of Bessel filter";
  constant Real bf=0.6180 "s*s coefficient of Bessel filter";
public 
  Interfaces.Flange_b flange_b;
  Modelica.Blocks.Interfaces.InPort inPort(final n=1) 
    "Flange position as input signal";
equation 
  s_ref = inPort.signal[1];
  s = flange_b.s;
  v = der(s);
  a = der(v);
  
  if exact then
    s = s_ref;
  else
    // Filter: a = s_ref/(1 + (af/w_crit)*S + (bf/w_crit^2)*S^2)
    a = ((s_ref - s)*w_crit - af*v)*(w_crit/bf);
  end if;
  
initial equation 
  if not exact then
    s = s_ref;
  end if;
end Position;

Modelica.Mechanics.Translational.Accelerate

Information

The input signal "a" in [m/s2] of connector "i" moves the 1D translational flange connector flange_b with a predefined acceleration, i.e., the flange is forced to move with this acceleration. The velocity and the position of the flange are also predefined and are determined by integration of the acceleration.

The acceleration "a(t)" can be provided from one of the signal generator blocks of the block library Modelica.Blocks.Source.

Release Notes:

• First Version from August 26, 1999 by P. Beater (based on Rotational.AccMotion)

Parameters

Name	Default	Description
s_start	0	Start position [m]
v_start	0	Start velocity [m/s]

Modelica definition

model Accelerate 
  "Forced movement of a flange according to an acceleration signal" 
  parameter SI.Position s_start=0 "Start position";
  parameter SI.Velocity v_start=0 "Start velocity";
  
  SI.Acceleration a "absolute acceleration of flange_b";
  SI.Velocity v(final start=v_start, final fixed=true) 
    "absolute velocity of flange_b";
  SI.Position s(final start=s_start, final fixed=true) 
    "absolute position of flange_b";
  
  Modelica.Blocks.Interfaces.InPort inPort(final n=1) 
    "Connector of input signal used as force";
  Interfaces.Flange_b flange_b;
equation 
  s = flange_b.s;
  v = der(s);
  a = der(v);
  a = inPort.signal[1];
end Accelerate;

Modelica.Mechanics.Translational.Move

Information

Flange flange_b is forced to move with a predefined motion according to the input signals:

    inPort.signal[1]: position of flange
    inPort.signal[2]: velocity of flange
    inPort.signal[3]: acceleration of flange

The user has to guarantee that the input signals are consistent to each other, i.e., that inPort.signal[2] is the derivative of inPort.signal[1] and that inPort.signal[3] is the derivative of inPort.signal[2]. There are, however, also applications where by purpose these conditions do not hold. For example, if only the position dependent terms of a mechanical system shall be calculated, one may provide position = position(t) and set the velocity and the acceleration to zero.

The input signals can be provided from one of the signal generator blocks of the block library Modelica.Blocks.Sources.

Note, this model utilizes the non-standard function constrain(..) and assumes that this function is supported by the Modelica translator:

   Real r[:], rd[:], rdd[:];
      ...
   r   = ..
   rd  = ...
   rdd = ...
   constrain(r,rd,rdd);

where r, rd and rdd are variables which need to be computed somewhere else. A simple implementation of constrain() is:

   r = 0;

However, this implementation requires that r(t) is given as analytical, smooth function in order that it can be differentiated and it does not allow applications such as the one sketched above. Function constrain() is used to explicitly inform the Modelica translator that rd is the derivative of r and rdd is the derivative of rd and that all derivatives need to be identical to zero. The Modelica translator can utilize this information to use rd and rdd whenever the Pantelides algorithm requires to compute the derivatives of r (and takes rd and rdd instead of actually differentiating r).

Release Notes:

• June 25, 2001 by Martin Otter:
  realized.

Modelica definition

model Move 
  "Forced movement of a flange according to a position, velocity and acceleration signal"
   
  
  SI.Position s "absolute position of flange_b";
  SI.Velocity v "absolute velocity of flange_b";
  SI.Acceleration a "absolute acceleration of flange_b";
  
protected 
  Real constraintResidue;
  Real constraintResidue_d;
  Real constraintResidue_dd;
public 
  Modelica.Blocks.Interfaces.InPort inPort(final n=3);
  Interfaces.Flange_b flange_b;
equation 
  s = flange_b.s;
  v = der(s);
  a = der(v);
  
  constraintResidue = inPort.signal[1] - s;
  constraintResidue_d = inPort.signal[2] - v;
  constraintResidue_dd = inPort.signal[3] - a;
  constrain(constraintResidue, constraintResidue_d, constraintResidue_dd);
end Move;

Modelica.Mechanics.Translational.Fixed

Information

The flange of a 1D translational mechanical system fixed at an position s0 in the housing. May be used:

• to connect a compliant element, such as a spring or a damper, between a sliding mass and the housing.
• to fix a rigid element, such as a sliding mass, at a specific position.

Release Notes:

• First Version from August 26, 1999 by P. Beater (based on Rotational.LockedR)

Parameters

Name	Default	Description
s0	0	fixed offset position of housing [m]

Modelica definition

model Fixed "Fixed flange" 
  parameter SI.Position s0=0 "fixed offset position of housing";
  
  Interfaces.Flange_b flange_b;
equation 
  flange_b.s = s0;
end Fixed;

Modelica.Mechanics.Translational.Force

Information

The input signal "s" in [N] characterizes an external force which acts (with positive sign) at a flange, i.e., the component connected to the flange is driven by force f.

Input signal s can be provided from one of the signal generator blocks of Modelica.Blocks.Source.

Release Notes:

• First Version from August 26, 1999 by P. Beater (based on Rotational.Torque1D)

Modelica definition

model Force 
  "External force acting on a drive train element as input signal" 
  
  SI.Force f "driving force";
  
  Interfaces.Flange_b flange_b;
  Modelica.Blocks.Interfaces.InPort inPort(final n=1) 
    "Connector of input signal used as force";
equation 
  f = inPort.signal[1];
  flange_b.f = -f;
end Force;

Modelica.Mechanics.Translational.RelativeStates

Information

Usually, the absolute position and the absolute velocity of Modelica.Mechanics.Translational.Inertia models are used as state variables. In some circumstances, relative quantities are better suited, e.g., because it may be easier to supply initial values. In such cases, model RelativeStates allows the definition of state variables in the following way:

• Connect an instance of this model between two flange connectors.
• The relative position and the relative velocity between the two connectors are used as state variables.

An example is given in the next figure

Here, the relative position and the relative velocity between the two masses are used as state variables. Additionally, the simulator selects either the absolute position and absolute velocity of model mass1 or of model mass2 as state variables.

Release Notes:

• June 19, 2000 by Martin Otter:
  Realized.

Modelica definition

model RelativeStates "Definition of relative state variables" 
  extends Interfaces.TwoFlanges;
  SI.Position s_rel(stateSelect=StateSelect.prefer) 
    "relative position used as state variable";
  SI.Velocity v_rel(stateSelect=StateSelect.prefer) 
    "relative velocity used as state variable";
  SI.Acceleration a_rel "relative angular acceleration";
equation 
  s_rel = flange_b.s - flange_a.s;
  v_rel = der(s_rel);
  a_rel = der(v_rel);
  flange_a.f = 0;
  flange_b.f = 0;
end RelativeStates;