Merge pull request #22 from JuliaComputing/smc

add sliding mode control example

docs/make.jl

@@ -33,6 +33,7 @@ makedocs(;
              "Examples" => [
                 "Controlled DC motor" => "examples/dc_motor_pi.md",
                 "On-off controller" => "examples/onoffcontroller.md",
+                "Sliding-mode control" => "examples/sliding_mode_control.md",
              ],
              "Library API" => "blocks.md",
          ],

docs/src/examples/sliding_mode_control.md

@@ -0,0 +1,93 @@
+# Sliding-mode control
+This example demonstrates how to model a system with a discrete-time sliding-mode controller using ModelingToolkit. The system consists of a second-order plant with a disturbance and a super-twisting sliding-mode controller. The controller is implemented as a discrete-time system, and the plant is modeled as a continuous-time system. 
+
+When designing an SMC controller, we must choose a _switching function_ ``σ`` that produces the sliding variable ``s = σ(x, p, t)``. The sliding surface ``s=0`` must be chosen such that the sliding variable ``s`` exhibits desireable properties, i.e., converges to the desired state with stable dynamics. The control law is chosen to drive the system from any state ``x : s ≠ 0`` to the sliding surface ``s=0``. The sliding surface is commonly chosen as an asymptotically stable system with order equal to the ``n_x-n_u``, where ``n_x`` is the dimension of the state in the system to be controlled, and ``n_u`` is the number of inputs.
+
+Since the dynamics in this example is of relative degree ``r=2``, we will choose a switching surface corresponding to a stable first-order system (``r-1=1``). We will choose the system
+```math
+ė = -e
+```
+which yields the switching variable ``s = ė + e``, encoded in the function ``s = σ(x, t)``
+
+```@example ONOFF
+using ModelingToolkit, ModelingToolkitSampledData, OrdinaryDiffEq, Plots
+using ModelingToolkit: t_nounits as t, D_nounits as D
+using ModelingToolkitStandardLibrary.Blocks
+using JuliaSimCompiler
+dt = 0.01
+clock = Clock(dt)
+z = ShiftIndex(clock)
+
+qr(t) = 1sin(2t)  # reference position
+qdr(t) = 2cos(2t) # reference velocity
+
+function σ(x, t)
+    q, qd = x
+    e = q - qr(t)
+    ė = qd - qdr(t)
+    ė + e
+end
+
+@register_symbolic σ(x, t::Real)
+
+@mtkmodel SuperTwistingSMC begin
+    @structural_parameters begin
+        z = ShiftIndex()
+        Ts = SampleTime()
+        nin
+    end
+    @components begin
+        input = RealInput(; nin)
+        output = RealOutput()
+    end
+    @parameters begin
+        k = 1,    [description = "Control gain"]
+        k2 = 1.1, [description = "Tuning parameter, often set to 1.1"]
+    end
+    @variables begin
+        s(t) = 0.0, [description = "Sliding surface"]
+        p(t) = 0.0
+        y(t) = 0.0, [description = "Control signal output"]
+        x(t) = 0.0
+        xd(t) = 0.0
+    end
+    @equations begin
+        s(z) ~ σ(input.u, t)
+        p  ~ -√(k*abs(s))*sign(s)
+        xd ~ -k2*k*sign(s)
+        x(z) ~ x(z-1) + Ts*xd # Fwd Euler integration
+        y ~ p + x
+        output.u ~ y
+    end
+end
+
+
+@mtkmodel ClosedLoopModel begin
+    @components begin
+        plant = SecondOrder(;)
+        zoh = ZeroOrderHold()
+        controller = SuperTwistingSMC(nin = 2, k=50)
+    end
+    @variables begin
+        disturbance(t) = 0.0
+    end 
+    @equations begin
+        controller.input.u ~ [Sample(dt)(plant.x), Sample(dt)(plant.xd)]
+        disturbance ~ 2 + 2sin(3t) + sin(5t)
+        connect(controller.output, zoh.input)
+        zoh.output.u + disturbance ~ plant.input.u
+    end
+end
+@named m = ClosedLoopModel()
+m = complete(m)
+ssys = structural_simplify(IRSystem(m))
+prob = ODEProblem(ssys, [m.plant.x => -1, m.plant.xd => 0, m.controller.x(z-1) => 0], (0.0, 2π))
+sol = solve(prob, Tsit5(), dtmax=0.01)
+figy = plot(sol, idxs=[m.plant.x])
+plot!(sol.t, qr.(sol.t), label="Reference")
+figu = plot(sol, idxs=[m.zoh.y, m.disturbance], label=["Control signal" "Disturbance"])
+plot(figy, figu, layout=(2,1))
+```
+
+The simulation indicates that the controller is able to track the reference signal despite the presence of the disturbance. The control signal exhibits a small degree of high-frequency chattering, a common characteristic of sliding-mode controllers.
+

src/discrete_blocks.jl

@@ -987,7 +987,7 @@ Discrete-time On-Off controller with hysteresis. The controller switches between
 # Parameters:
 - `b`: Bandwidth around reference signal within which the controller does not react
 - `bool`: (structural) If true (default), the controller switches between 0 and 1. If false, the controller switches between -1 and 1.
-- `k`: Controller gain. The output of the contorller is scaled by this gain, i.e., `k = 2, bool = false` will result in an output of -2 or 2.
+- `k`: Controller gain. The output of the controller is scaled by this gain, i.e., `k = 2, bool = false` will result in an output of -2 or 2.
 """
 @mtkmodel DiscreteOnOffController begin
     @extend u, y = siso = SISO()