Throw DomainError when conversion to other form is not possible

lib/ControlSystemsBase/src/pid_design.jl

@@ -48,41 +48,41 @@
 @deprecate pid(; kp=0, ki=0, kd=0, series = false) pid(kp, ki, kd; form=series ? :series : :parallel)
 
 function pid_tf(param_p, param_i, param_d=zero(typeof(param_p)); form=:standard,  Tf=nothing)
     Kp, Ki, Kd = convert_pidparams_to_parallel(param_p, param_i, param_d, form)
     if isnothing(Tf)
         if Ki != 0
             return tf([Kd, Kp, Ki], [1, 0])
         else
             return tf([Kd, Kp], [1])
         end
     else
         if Ki != 0
             return tf([Kd, Kp, Ki], [Tf^2/2, Tf, 1, 0])
         else
             return tf([Kd, Kp], [Tf^2/2, Tf, 1])
         end
     end
 end
 
 function pid_ss(param_p, param_i, param_d=zero(typeof(param_p)); form=:standard,  Tf=nothing)
     Kp, Ki, Kd = convert_pidparams_to_parallel(param_p, param_i, param_d, form)
     TE = Continuous()
     if !isnothing(Tf)
         if Ki != 0
             A = [0 1 0; 0 0 1; 0 -2/Tf^2 -2/Tf]
             B = [0; 0; 1]
             C = 2 / Tf^2 * [Ki Kp Kd]
         else
             A = [0 1; -2/Tf^2 -2/Tf]
             B = [0; 1]
             C = 2 / Tf^2 * [Kp Kd]
         end
         D = 0
     elseif Kd == 0
         if Ki != 0
             A = 0
             B = 1
             C = Ki # Ti == 0 would result in division by zero, but typically indicates that the user wants no integral action
             D = Kp
         else
             return ss([Kp])
@@ -489,7 +489,7 @@
     verbose && ki < 0 && @warn "Calculated ki is negative, inspect the Nyquist plot generated with doplot = true and try adjusting ω or the angle ϕt"
     C = pid(kp, ki, kd, form=:parallel)
     any(real(p) > 0 for p in poles(C)) && @error "Calculated controller is unstable."
     kp, ki, kd = convert_pidparams_from_to(kp, ki, kd, :parallel, form)
     CF = C*F
     fig = if doplot
         w = exp10.(LinRange(log10(ω)-2, log10(ω)+2, 1000))
@@ -518,17 +518,17 @@
 * `:series` - ``K_c(1 + 1/(τ_i s))(τ_d s + 1)``
 * `:parallel` - ``K_p + K_i/s + K_d s``
 """
 function convert_pidparams_to_parallel(param_p, param_i, param_d, form::Symbol)
     if form === :parallel
         return param_p, param_i, param_d
     elseif form === :series
         # param_i = 0 would result in division by zero, but typically indicates that the user wants no integral action
         param_i == 0 && return @. (param_p * (1, 0, param_d))
         return @. (param_p *
             ((param_i + param_d) / param_i, 1 / param_i, param_d))
     elseif form === :standard
         param_i == 0 && return @. param_p * (1, 0, param_d)
         return @. param_p * (1, 1 / param_i, param_d)
     else
         throw(ArgumentError("form $(form) not supported."))
     end
@@ -548,11 +548,12 @@
     if form === :standard
         return Kp, Ti, Td
     elseif form === :series
-        return @. (
-            (Ti - sqrt(Ti * (Ti - 4 * Td))) / 2 * Kp / Ti,
-            (Ti - sqrt(Ti * (Ti - 4 * Td))) / 2,
-            (Ti + sqrt(Ti * (Ti - 4 * Td))) / 2,
-        )
+        Δ = Ti * (Ti - 4 * Td)
+        Δ < 0 && throw(DomainError("The condition Ti^2 ≥ 4Td*Ti is not satisfied: the PID parameters cannot be converted to series form"))
+        sqrtΔ = sqrt(Δ)
+        return @. ((Ti - sqrtΔ) / 2 * Kp / Ti,
+                   (Ti - sqrtΔ) / 2,
+                   (Ti + sqrtΔ) / 2)
     elseif form === :parallel
         return @. (Kp, Kp/Ti, Td*Kp)
     else
@@ -571,22 +572,22 @@
 * `:series` - ``K_c(1 + 1/(τ_i s))(τ_d s + 1)``
 * `:parallel` - ``K_p + K_i/s + K_d s``
 """
 function convert_pidparams_from_parallel(param_p, param_i, param_d, to::Symbol)
     if to === :parallel
         return param_p, param_i, param_d
     elseif to === :series
         param_i == 0 && return @. (param_p * (1, 0, param_d))
         Δ = param_p^2-4param_i*param_d
         Δ < 0 &&
-            error("The condition KP^2-4KI*KD ≥ 0 is not satisfied: the parameters cannot be converted")
+            throw(DomainError("The condition KP^2 ≥ 4KI*KD is not satisfied: the PID parameters cannot be converted to series form"))
         sqrtΔ = sqrt(Δ)
         return @. ((param_p - sqrtΔ)/2, (param_p - sqrtΔ)/(2param_i), (param_p + sqrtΔ)/(2param_i))
     elseif to === :standard
-        param_p == 0 && error("Cannot convert to standard form when Kp=0")
+        param_p == 0 && throw(DomainError("Cannot convert to standard form when Kp=0"))
         param_i == 0 && return @. (param_p, Inf, param_d / param_p)
         return @. (param_p, param_p / param_i, param_d / param_p)
     else
         throw(ArgumentError("form $(form) not supported."))
     end
 end
 
@@ -595,6 +596,6 @@
     convert_pidparams_from_to(kp, ki, kd, from::Symbol, to::Symbol)
 """
 function convert_pidparams_from_to(kp, ki, kd, from::Symbol, to::Symbol)
     kp, ki, kd = convert_pidparams_to_parallel(kp, ki, kd, from)
     convert_pidparams_from_parallel(kp, ki, kd, to)
 end

lib/ControlSystemsBase/test/test_pid_design.jl

@@ -1,5 +1,7 @@
 @testset "test_pid_design" begin
 
+CSB = ControlSystemsBase
+
 # Test gof plot and loopshaping
 P = tf(1,[1,1])^4
 gangoffourplot(P,tf(1))
@@ -15,6 +17,9 @@ C, kp, ki = loopshapingPI(P, ωp, phasemargin=60, form=:parallel, doplot=true)
 @test pid(1.0, Inf, 1) == tf(1) + tf([1, 0], [1])
 @test pid(1.0, 0, 1) == tf(1) + tf([1, 0], [1])
 @test pid(0.0, 1, 1; form=:parallel) == tf(0) + tf(1,[1,0]) + tf([1,0],[1])
+@test_throws DomainError CSB.convert_pidparams_from_parallel(2, 3, 0.5, :series)
+@test_throws DomainError CSB.convert_pidparams_from_parallel(0, 3, 0.5, :standard)
+@test_throws DomainError CSB.convert_pidparams_from_standard(2, 1, 0.5, :series)
 # ss
 @test tf(pid(1.0, 1, 0; state_space=true)) == tf(1) + tf(1,[1,0])