Merge pull request #721 from JuliaControl/deadzone

add deadzone nonlinearity

Author: baggepinnen

docs/src/lib/nonlinear.md

@@ -238,7 +238,6 @@ plot(f1,f2, size=(1300,800))
 - Discrete-time support.
 - Basic support for nonlinear analysis such as stability proof through the circle criterion etc. In particular, predefined nonlinear functions may specify sector bounds for the gain, required by the circle-criterion calculations.
 - Additional nonlinear components, such as 
-    - Dead zone
     - Integrator anti-windup
     - Friction models?
 
@@ -249,4 +248,5 @@ ControlSystems.nonlinearity
 ControlSystems.offset
 ControlSystems.saturation
 ControlSystems.ratelimit
+ControlSystems.deadzone
 ```

src/hammerstein_weiner.jl

@@ -229,54 +229,3 @@ function impulse(sys::HammersteinWienerSystem{T}, t::AbstractVector; kwargs...)
 end
 
 
-struct Saturation{T} <: Function
-    l::T
-    u::T
-end
-Saturation(u) = Saturation(-u, u)
-
-(s::Saturation)(x) = clamp(x, s.l, s.u)
-
-"""
-    saturation(val)
-    saturation(lower, upper)
-
-Create a saturating nonlinearity. Connect it to the output of a controller `C` using
-```
-Csat = saturation(val) * C
-```
-
-$nonlinear_warning
-
-Note: when composing linear systems with nonlinearities, it's often important to handle operating points correctly.
-See [`ControlSystems.offset`](@ref) for handling operating points.
-"""
-saturation(args...) = nonlinearity(Saturation(args...))
-saturation(v::AbstractVector, args...) = nonlinearity(Saturation.(v, args...))
-Base.show(io::IO, f::Saturation) = f.u == -f.l ? print(io, "saturation($(f.u))") : print(io, "saturation($(f.l), $(f.u))")
-
-struct Offset{T} <: Function
-    o::T
-end
-
-(s::Offset)(x) = x .+ s.o
-
-"""
-    offset(val)
-
-Create a constant-offset nonlinearity `x -> x + val`.
-
-$nonlinear_warning
-
-# Example:
-To create a linear system that operates around operating point `y₀, u₀`, use
-```julia
-offset_sys = offset(y₀) * sys * offset(-u₀)
-```
-note the sign on the offset `u₀`. This ensures that `sys` operates in the coordinates
-`Δu = u-u₀, Δy = y-y₀` and the inputs and outputs to the offset system are in their non-offset coordinate system. If the system is linearized around `x₀`, `y₀` is given by `C*x₀`. Additional information and an example is available here https://juliacontrol.github.io/ControlSystems.jl/latest/lib/nonlinear/#Non-zero-operating-point
-"""
-offset(val::Number) = nonlinearity(Offset(val))
-offset(v::AbstractVector) = nonlinearity(Offset.(v))
-
-Base.show(io::IO, f::Offset) = print(io, "offset($(f.o))")

src/nonlinear_components.jl

@@ -1,3 +1,73 @@
+struct Saturation{T} <: Function
+    l::T
+    u::T
+end
+Saturation(u) = Saturation(-u, u)
+
+(s::Saturation)(x) = clamp(x, s.l, s.u)
+
+"""
+    saturation(val)
+    saturation(lower, upper)
+
+Create a saturating nonlinearity. Connect it to the output of a controller `C` using
+```
+Csat = saturation(val) * C
+```
+
+```
+           y▲   ────── upper
+            │  /
+            │ /
+            │/
+  ──────────┼────────► u
+           /│   
+          / │
+         /  │
+lower──── 
+```
+
+$nonlinear_warning
+
+Note: when composing linear systems with nonlinearities, it's often important to handle operating points correctly.
+See [`ControlSystems.offset`](@ref) for handling operating points.
+"""
+saturation(args...) = nonlinearity(Saturation(args...))
+saturation(v::AbstractVector, args...) = nonlinearity(Saturation.(v, args...))
+Base.show(io::IO, f::Saturation) = f.u == -f.l ? print(io, "saturation($(f.u))") : print(io, "saturation($(f.l), $(f.u))")
+
+## Offset ======================================================================
+
+struct Offset{T} <: Function
+    o::T
+end
+
+(s::Offset)(x) = x .+ s.o
+
+"""
+    offset(val)
+
+Create a constant-offset nonlinearity `x -> x + val`.
+
+$nonlinear_warning
+
+# Example:
+To create a linear system that operates around operating point `y₀, u₀`, use
+```julia
+offset_sys = offset(y₀) * sys * offset(-u₀)
+```
+note the sign on the offset `u₀`. This ensures that `sys` operates in the coordinates
+`Δu = u-u₀, Δy = y-y₀` and the inputs and outputs to the offset system are in their non-offset coordinate system. If the system is linearized around `x₀`, `y₀` is given by `C*x₀`. Additional information and an example is available here https://juliacontrol.github.io/ControlSystems.jl/latest/lib/nonlinear/#Non-zero-operating-point
+"""
+offset(val::Number) = nonlinearity(Offset(val))
+offset(v::AbstractVector) = nonlinearity(Offset.(v))
+
+Base.show(io::IO, f::Offset) = print(io, "offset($(f.o))")
+
+
+
+## Ratelimit ===================================================================
+
 """
     ratelimit(val; Tf)
     ratelimit(lower, upper; Tf)
@@ -17,3 +87,48 @@ function ratelimit(args...; Tf)
     integrator*saturation(args...)*F
 end
 
+
+
+## DeadZone ====================================================================
+
+struct DeadZone{T} <: Function
+    l::T
+    u::T
+end
+DeadZone(u) = DeadZone(-u, u)
+
+function (s::DeadZone)(x)
+    if x > s.u
+        x - s.u
+    elseif x < s.l
+        x - s.l
+    else
+        zero(x)
+    end
+end
+
+"""
+    deadzone(val)
+    deadzone(lower, upper)
+
+Create a dead-zone nonlinearity.
+
+```
+       y▲
+        │     /
+        │    /
+  lower │   /
+─────|──┼──|───────► u
+    /   │   upper
+   /    │
+  /     │
+```
+
+$nonlinear_warning
+
+Note: when composing linear systems with nonlinearities, it's often important to handle operating points correctly.
+See [`ControlSystems.offset`](@ref) for handling operating points.
+"""
+deadzone(args...) = nonlinearity(DeadZone(args...))
+deadzone(v::AbstractVector, args...) = nonlinearity(DeadZone.(v, args...))
+Base.show(io::IO, f::DeadZone) = f.u == -f.l ? print(io, "deadzone($(f.u))") : print(io, "deadzone($(f.l), $(f.u))")

test/test_nonlinear_components.jl

@@ -12,3 +12,19 @@ end
 
 ##
 
+using ControlSystems
+using ControlSystems: deadzone
+
+th = 0.7
+@show nl = deadzone(th)
+res = lsim(nl, (x,t)->sin(t), 0:0.01:4pi)
+# plot(res)
+@test minimum(res.y) ≈ -0.3 rtol=1e-3
+@test maximum(res.y) ≈ 0.3 rtol=1e-3
+
+@show nl = deadzone(-2th, th)
+res = lsim(nl, (x,t)->2sin(t), 0:0.01:4pi)
+# plot(res)
+@test minimum(res.y) ≈ -0.6 rtol=1e-3
+@test maximum(res.y) ≈ 1.3 rtol=1e-3
+