执行器 (文档字符串)¶

用于联动力和力矩应用的执行器实现。

class sympy.physics.mechanics.actuator.ActuatorBase[源代码][源代码]¶

所有执行器类的抽象基类，供其继承。

方法

to_loads()

加载由运动方程方法类所需的。

注释

此类实例不能被用户直接实例化。然而，它可以通过子类化来创建自定义执行器类型。

abstract to_loads()[源代码][源代码]¶: 加载由运动方程方法类所需的。

class sympy.physics.mechanics.actuator.CoulombKineticFriction( mu_k, f_n, pathway, *, v_s=None, sigma=None, mu_s=None, )[源代码][源代码]¶

考虑Stribeck和粘性效应的库仑动摩擦。

参数:

f_nsympifiable: 表面之间的法向力。它应该始终是一个非负的标量。
mu_ksympifiable: 动摩擦系数。
路径PathwayBase: 执行器所遵循的路径。
v_s可符号化，可选: Stribeck 摩擦系数。
sigma可符号化，可选: 粘性摩擦系数。
mu_s可符号化，可选: 静摩擦系数。默认为 mu_k，这意味着 Stribeck 效应默认评估为 0。

属性:

f_n: 表面之间的法向力。
force: 执行器产生的力的大小。
mu_k: 动摩擦系数。
mu_s: 静摩擦系数。
pathway: 定义执行器作用线的 Pathway。
sigma: 粘性摩擦系数。
v_s: Stribeck 摩擦系数。

方法

to_loads()

加载由运动方程方法类所需的。

注释

执行器做出以下假设：

执行器假设相对运动是非零的。
法向力被假定为非负标量。
产生的摩擦力方向与速度方向相反。
路径中的每个点都固定在相互滑动的独立对象中。换句话说，这两个点固定在相互滑动的对象中。

该执行器已针对简单的运动进行了测试，例如块在表面上滑动。

摩擦力被定义为总是与相对速度 \(v\) 的方向相反。具体来说：

默认的库仑摩擦力 \(\mu_k f_n \text{sign}(v)\) 与 \(v\) 方向相反。
Stribeck效应 \((\mu_s - \mu_k) f_n e^{-(\frac{v}{v_s})^2} \text{sign}(v)\) 也与 \(v\) 相反。
粘性摩擦项 \(\sigma v\) 与 \(v\) 方向相反。

参考文献

[Moore2022]

https://moorepants.github.io/learn-multibody-dynamics/loads.html#friction.

[Flores2023]

Paulo Flores, Jorge Ambrosio, Hamid M. Lankarani, “多体动力学中的摩擦接触-冲击事件：回归基础”, 机械与机器理论, 第184卷, 2023. https://doi.org/10.1016/j.mechmachtheory.2023.105305.

[Rogner2017]

I. Rogner, “Friction modelling for robotic applications with planar motion”, Chalmers University of Technology, Department of Electrical Engineering, 2017.

示例

下面的示例展示了如何在具有摩擦的弹簧质量系统中生成由库仑动摩擦执行器产生的负载。

>>> import sympy as sm
>>> from sympy.physics.mechanics import (dynamicsymbols, ReferenceFrame, Point,
...     LinearPathway, CoulombKineticFriction, LinearSpring, KanesMethod, Particle)

>>> x, v = dynamicsymbols('x, v', real=True)
>>> m, g, k, mu_k, mu_s, v_s, sigma = sm.symbols('m, g, k, mu_k, mu_s, v_s, sigma')

>>> N = ReferenceFrame('N')
>>> O, P = Point('O'), Point('P')
>>> O.set_vel(N, 0)
>>> P.set_pos(O, x*N.x)

>>> pathway = LinearPathway(O, P)
>>> friction = CoulombKineticFriction(mu_k, m*g, pathway, v_s=v_s, sigma=sigma, mu_s=mu_k)
>>> spring = LinearSpring(k, pathway)
>>> block = Particle('block', point=P, mass=m)

>>> kane = KanesMethod(N, (x,), (v,), kd_eqs=(x.diff() - v,))
>>> friction.to_loads()
    [(O, (g*m*mu_k*sign(sign(x(t))*Derivative(x(t), t)) + sigma*sign(x(t))*Derivative(x(t), t))*x(t)/Abs(x(t))*N.x), (P, (-g*m*mu_k*sign(sign(x(t))*Derivative(x(t), t)) - sigma*sign(x(t))*Derivative(x(t), t))*x(t)/Abs(x(t))*N.x)]
>>> loads = friction.to_loads() + spring.to_loads()
>>> fr, frstar = kane.kanes_equations([block], loads)
>>> eom = fr + frstar
>>> eom
    Matrix([[-k*x(t) - m*Derivative(v(t), t) + (-g*m*mu_k*sign(v(t)*sign(x(t))) - sigma*v(t)*sign(x(t)))*x(t)/Abs(x(t))]])

property f_n¶: 表面之间的法向力。

property mu_k¶: 动摩擦系数。

property mu_s¶: 静摩擦系数。

property sigma¶: 粘性摩擦系数。

property v_s¶: Stribeck 摩擦系数。

class sympy.physics.mechanics.actuator.DuffingSpring( linear_stiffness, nonlinear_stiffness, pathway, equilibrium_length=0, )[源代码][源代码]¶

基于Duffing方程的非线性弹簧。

参数:

线性刚度表达式: 线性刚度系数（beta）。
nonlinear_stiffness表达式: 非线性刚度系数（alpha）。
路径PathwayBase: 执行器所遵循的路径。
平衡长度Expr, 可选: 弹簧处于平衡状态时的长度（x）。

属性:

平衡长度
force: Duffing 弹簧产生的力。
线性刚度
nonlinear_stiffness
pathway: 定义执行器作用线的 Pathway。

方法

to_loads()

加载由运动方程方法类所需的。

property force¶: Duffing 弹簧产生的力。

class sympy.physics.mechanics.actuator.ForceActuator(force, pathway)[源代码][源代码]¶

产生力的执行器。

参数:

强制表达式: 定义执行器产生的（可扩展的）力的标量表达式。
路径PathwayBase: 执行器遵循的路径。这必须是一个 PathwayBase 的具体子类的实例，例如 LinearPathway。

属性:

force: 执行器产生的力的大小。
pathway: 定义执行器作用线的 Pathway。

方法

to_loads()

加载由运动方程方法类所需的。

示例

要构造一个执行器，必须提供一个表达式（或符号）来表示它能产生的力，以及指定其作用线的路径。我们还需要创建一个全局参考框架，并在其中固定一个点，同时将另一个点设置为可以在框架的 x 方向上自由移动，该方向由坐标 q 指定。

>>> from sympy import symbols
>>> from sympy.physics.mechanics import (ForceActuator, LinearPathway,
...     Point, ReferenceFrame)
>>> from sympy.physics.vector import dynamicsymbols
>>> N = ReferenceFrame('N')
>>> q = dynamicsymbols('q')
>>> force = symbols('F')
>>> pA, pB = Point('pA'), Point('pB')
>>> pA.set_vel(N, 0)
>>> pB.set_pos(pA, q*N.x)
>>> pB.pos_from(pA)
q(t)*N.x
>>> linear_pathway = LinearPathway(pA, pB)
>>> actuator = ForceActuator(force, linear_pathway)
>>> actuator
ForceActuator(F, LinearPathway(pA, pB))

property force¶: 执行器产生的力的大小。

property pathway¶: 定义执行器作用线的 Pathway。

to_loads()[源代码][源代码]¶

加载由运动方程方法类所需的。

示例

下面的示例展示了如何生成由一个沿着线性路径运动的力执行器产生的载荷。在这个示例中，我们假设力执行器用于模拟一个简单的线性弹簧。首先，在全局坐标系 N 的 x 方向上，创建两个由坐标 q 分隔的点之间的线性路径。

>>> from sympy.physics.mechanics import (LinearPathway, Point,
...     ReferenceFrame)
>>> from sympy.physics.vector import dynamicsymbols
>>> q = dynamicsymbols('q')
>>> N = ReferenceFrame('N')
>>> pA, pB = Point('pA'), Point('pB')
>>> pB.set_pos(pA, q*N.x)
>>> pathway = LinearPathway(pA, pB)

现在创建一个符号 k 来描述弹簧的刚度，并实例化一个力执行器，该执行器产生一个与弹簧刚度和路径长度成比例的（收缩）力。注意，执行器类使用扩展力为正的符号约定，因此对于弹簧产生收缩力，弹簧力需要计算为刚度乘以长度的负值。

>>> from sympy import symbols
>>> from sympy.physics.mechanics import ForceActuator
>>> stiffness = symbols('k')
>>> spring_force = -stiffness*pathway.length
>>> spring = ForceActuator(spring_force, pathway)

弹簧产生的力可以通过调用 to_loads 方法生成，以满足 ``KanesMethod``（和其他运动方程方法）在载荷列表形式中的要求。

>>> spring.to_loads()
[(pA, k*q(t)*N.x), (pB, - k*q(t)*N.x)]

一个简单的线性阻尼器可以用类似的方式建模。创建另一个符号 c 来描述阻尼器的阻尼系数。这次实例化一个力执行器，它产生的力与阻尼器的阻尼系数和路径的延伸速度成正比。注意，阻尼力是负的，因为它作用的方向与阻尼器长度变化的方向相反。

>>> damping_coefficient = symbols('c')
>>> damping_force = -damping_coefficient*pathway.extension_velocity
>>> damper = ForceActuator(damping_force, pathway)

同样，阻尼器产生的力可以通过调用 to_loads 方法生成。

>>> damper.to_loads()
[(pA, c*Derivative(q(t), t)*N.x), (pB, - c*Derivative(q(t), t)*N.x)]

class sympy.physics.mechanics.actuator.LinearDamper(damping, pathway)[源代码][源代码]¶

一个阻尼器，其力是其延伸速度的线性函数。

参数:

阻尼表达式: 阻尼常数。
路径PathwayBase: 执行器遵循的路径。这必须是一个 PathwayBase 的具体子类的实例，例如 LinearPathway。

属性:

damping: 线性阻尼器的阻尼常数。
force: 线性阻尼器产生的阻尼力。
pathway: 定义执行器作用线的 Pathway。

方法

to_loads()

加载由运动方程方法类所需的。

参见

ForceActuator: 力产生执行器（LinearDamper 的父类）。
LinearPathway: 两点之间的直线路径。

示例

要构建一个线性阻尼器，必须提供一个表达式（或符号）来表示阻尼器的阻尼系数（我们将使用符号 c），并指定其作用路径。我们还需要创建一个全局参考系，并在其中固定一个点，同时将另一个点设置为可以在参考系的 x 方向上自由移动，该方向由坐标 q 指定。两个点相互远离的速度可以通过坐标 u 指定，其中 u 是 q 的一阶时间导数（即 u = Derivative(q(t), t)）。

>>> from sympy import symbols
>>> from sympy.physics.mechanics import (LinearDamper, LinearPathway,
...     Point, ReferenceFrame)
>>> from sympy.physics.vector import dynamicsymbols
>>> N = ReferenceFrame('N')
>>> q = dynamicsymbols('q')
>>> damping = symbols('c')
>>> pA, pB = Point('pA'), Point('pB')
>>> pA.set_vel(N, 0)
>>> pB.set_pos(pA, q*N.x)
>>> pB.pos_from(pA)
q(t)*N.x
>>> pB.vel(N)
Derivative(q(t), t)*N.x
>>> linear_pathway = LinearPathway(pA, pB)
>>> damper = LinearDamper(damping, linear_pathway)
>>> damper
LinearDamper(c, LinearPathway(pA, pB))

这个阻尼器将产生一个力，该力与其阻尼系数和路径的延伸长度成正比。注意，这个力是负的，因为SymPy对执行器的符号约定是负力是收缩的，并且阻尼器的阻尼力将抵抗长度变化的方向。

>>> damper.force
-c*sqrt(q(t)**2)*Derivative(q(t), t)/q(t)

property damping¶: 线性阻尼器的阻尼常数。

property force¶: 线性阻尼器产生的阻尼力。

class sympy.physics.mechanics.actuator.LinearSpring( stiffness, pathway, equilibrium_length=0, )[源代码][源代码]¶

一个弹簧，其弹力是其长度的线性函数。

参数:

刚度表达式: 弹簧常数。
路径PathwayBase: 执行器遵循的路径。这必须是一个 PathwayBase 的具体子类的实例，例如 LinearPathway。
平衡长度Expr, 可选: 弹簧处于平衡状态的长度，即它不产生力。默认值为0，即弹簧力是路径长度的线性函数，没有常数偏移。

属性:

equilibrium_length: 弹簧在产生无力的长度。
force: 由线性弹簧产生的弹簧力。
pathway: 定义执行器作用线的 Pathway。
stiffness: 线性弹簧的弹簧常数。

方法

to_loads()

加载由运动方程方法类所需的。

参见

ForceActuator: 产生力的执行器（LinearSpring 的父类）。
LinearPathway: 两点之间的直线路径。

示例

要构建一个线性弹簧，必须提供一个表达式（或符号）来表示弹簧的刚度（弹簧常数），以及指定其作用线的路径。我们还需要创建一个全局参考框架，并在其中空间固定一个点，同时将另一个点设置为可以在框架的 x 方向自由移动，该方向由坐标 q 指定。

>>> from sympy import symbols
>>> from sympy.physics.mechanics import (LinearPathway, LinearSpring,
...     Point, ReferenceFrame)
>>> from sympy.physics.vector import dynamicsymbols
>>> N = ReferenceFrame('N')
>>> q = dynamicsymbols('q')
>>> stiffness = symbols('k')
>>> pA, pB = Point('pA'), Point('pB')
>>> pA.set_vel(N, 0)
>>> pB.set_pos(pA, q*N.x)
>>> pB.pos_from(pA)
q(t)*N.x
>>> linear_pathway = LinearPathway(pA, pB)
>>> spring = LinearSpring(stiffness, linear_pathway)
>>> spring
LinearSpring(k, LinearPathway(pA, pB))

这个弹簧将产生一个力，该力与其刚度和路径长度成正比。请注意，这个力是负的，因为SymPy对执行器的符号约定是负力是收缩的。

>>> spring.force
-k*sqrt(q(t)**2)

要创建一个具有非零平衡长度的线性弹簧，可以在 LinearSpring 实例的构造过程中将表达式（或符号）传递给 equilibrium_length 参数。让我们创建一个符号 l 来表示非零平衡长度，并创建另一个线性弹簧。

>>> l = symbols('l')
>>> spring = LinearSpring(stiffness, linear_pathway, equilibrium_length=l)
>>> spring
LinearSpring(k, LinearPathway(pA, pB), equilibrium_length=l)

这个新弹簧的弹簧力再次与其刚度和路径长度成正比。然而，当 q(t) 等于 l 时，弹簧不会产生任何力。注意，当 q(t) 小于 l 时，力将变为扩张力，这是预期的。

>>> spring.force
-k*(-l + sqrt(q(t)**2))

property equilibrium_length¶: 弹簧在产生无力的长度。

property force¶: 由线性弹簧产生的弹簧力。

property stiffness¶: 线性弹簧的弹簧常数。

class sympy.physics.mechanics.actuator.TorqueActuator( torque, axis, target_frame, reaction_frame=None, )[源代码][源代码]¶

产生扭矩的执行器。

参数:

扭矩表达式: 定义执行器产生的扭矩的标量表达式。
轴向量: 执行器施加扭矩的轴。
目标框架参考坐标系 | 刚体: 执行器将施加扭矩的主要框架。
反应框架参考框架 | 刚体 | 无: 执行器将施加扭矩的次级框架。请注意，（大小相等、方向相反的）反作用扭矩施加在此框架上。

属性:

axis: 扭矩作用的轴。
reaction_frame: 扭矩将作用的主要参考系。
target_frame: 扭矩将作用的主要参考系。
torque: 执行器产生的扭矩的大小。

方法

`at_pin_joint`(torque, pin_joint)	从 `PinJoint` 实例实例化的替代构造函数。
`to_loads`()	加载由运动方程方法类所需的。

示例

要构建一个扭矩执行器，必须提供一个表达式（或符号）来表示它能产生的扭矩，同时指定一个矢量来表示扭矩作用的轴，以及一对扭矩作用的框架。

>>> from sympy import symbols
>>> from sympy.physics.mechanics import (ReferenceFrame, RigidBody,
...     TorqueActuator)
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> torque = symbols('T')
>>> axis = N.z
>>> parent = RigidBody('parent', frame=N)
>>> child = RigidBody('child', frame=A)
>>> bodies = (child, parent)
>>> actuator = TorqueActuator(torque, axis, *bodies)
>>> actuator
TorqueActuator(T, axis=N.z, target_frame=A, reaction_frame=N)

注意，因为扭矩实际上作用于框架，而不是物体，所以当传递一个 RigidBody 而不是 ReferenceFrame 时，TorqueActuator 将提取与该 RigidBody 关联的框架。

classmethod at_pin_joint(torque, pin_joint)[源代码][源代码]¶

从 PinJoint 实例实例化的替代构造函数。

参数:

扭矩表达式: 定义执行器产生的扭矩的标量表达式。
pin_jointPinJoint: 扭矩执行器将作用的销接头及其关联的父体和子体。扭矩执行器作用的两个体是销接头的父体和子体，其中子体作为反作用体。销接头的轴线用作扭矩执行器施加其扭矩的轴线。

示例

要创建一个销接头，PinJoint 类需要一个名称、父体和子体传递给其构造函数。还可以使用 joint_axis 关键字参数来控制接头轴。在这个例子中，让我们使用父体参考系的 z 轴作为接头轴。

>>> from sympy.physics.mechanics import (PinJoint, ReferenceFrame,
...     RigidBody, TorqueActuator)
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> parent = RigidBody('parent', frame=N)
>>> child = RigidBody('child', frame=A)
>>> pin_joint = PinJoint(
...     'pin',
...     parent,
...     child,
...     joint_axis=N.z,
... )

让我们也创建一个符号 T ，它将代表扭矩执行器施加的扭矩。

>>> from sympy import symbols
>>> torque = symbols('T')

要从之前实例化的 torque 和 pin_joint 变量创建扭矩执行器，可以将这些变量传递给 TorqueActuator 类的替代构造函数类方法 at_pin_joint。需要注意的是，正扭矩将导致关节坐标的正位移，或者扭矩施加在子体上，并在父体上产生反作用扭矩。

>>> actuator = TorqueActuator.at_pin_joint(torque, pin_joint)
>>> actuator
TorqueActuator(T, axis=N.z, target_frame=A, reaction_frame=N)

property axis¶: 扭矩作用的轴。

property reaction_frame¶: 扭矩将作用的主要参考系。

property target_frame¶: 扭矩将作用的主要参考系。

to_loads()[源代码][源代码]¶

加载由运动方程方法类所需的。

示例

下面的示例展示了如何生成由扭矩执行器产生的负载，该执行器作用于通过销接头连接的一对物体。

>>> from sympy import symbols
>>> from sympy.physics.mechanics import (PinJoint, ReferenceFrame,
...     RigidBody, TorqueActuator)
>>> torque = symbols('T')
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> parent = RigidBody('parent', frame=N)
>>> child = RigidBody('child', frame=A)
>>> pin_joint = PinJoint(
...     'pin',
...     parent,
...     child,
...     joint_axis=N.z,
... )
>>> actuator = TorqueActuator.at_pin_joint(torque, pin_joint)

阻尼器产生的力可以通过调用 to_loads 方法生成。

>>> actuator.to_loads()
[(A, T*N.z), (N, - T*N.z)]

另外，如果创建了一个没有反作用力框架的扭矩执行器，那么 to_loads 方法返回的载荷将只包含作用在目标框架上的单一载荷。

>>> actuator = TorqueActuator(torque, N.z, N)
>>> actuator.to_loads()
[(N, T*N.z)]

property torque¶: 执行器产生的扭矩的大小。