Scaling and parameterizing a controller

A method for producing a controller, comprising:

• normalizing a plant into a UGUB form plant yielding a gain scale and a frequency scale;
• identifying a controller function for the UGUB form plant given a desired closed loop transfer function;
• and
• programmatically scaling the controller function for the UGUB form plant to a desired controller function based on the gain scale and the frequency scale.

A method for producing a parameterized controller, comprising:

• selecting a controller to parameterize;
• identifying two or more scaleable parameters for the controller;
• programmatically relating the two or more scaleable parameters to a single controller parameter;
• relating a controller with the single controller parameter to a plant;
• and
• programmatically configuring the parameterized controller by configuring the single controller parameter.

A method for producing a controller, comprising:

• establishing one or more loop gain constraints based on one or more design specifications;
• programmatically accessing a parameterized loop shaping model;
• selecting a controller Gc(jω) from the model based on the one or more loop gain constraints;
• and
• programmatically establishing a loop gain frequency response of the form L(Jω)=Gp(jω)Gc(jω), where ωc is the bandwidth of a feedback control system and a controller Gc(s,ωc) related to the controller Gc(jω).

A method for designing and optimizing an LADRC, comprising:

• selecting a ωo and ωc based LESO and feedback control law;
• establishing a transient profile for the LADRC with an equivalent bandwidth of {overscore (ω)}c;
• selecting an ωo from ωo≈5␣10{overscore (ω)}c;
• setting ωc=ωo;
• inputting the feedback control, ωo and ωc, into an LADRC simulator;
• incrementally increasing ωc and ωo in the simulator until a constraint exceeds a pre-determined tolerance;
• and
• selectively incrementally changing ωc or ωo in the simulator until a desired behavior is observed.

A controller design method, comprising:

• identifying a plant transfer function for a plant to be controlled by the controller;
• computing a frequency scale ωp and a gain scale k for a controller from the plant transfer function;
• selecting a controller Gc(s, ωc) corresponding to a scaled plant in a known form based on the plant transfer function, the frequency scale, and the gain scale;
• scaling the controller according to
• 68 1 k ⁢ G c ⁡ ( s ω p , ω c ) ;
• digitizing Gc(s/ωp, ωc)/k;
• simulating the digitized controller in a computer component;
• setting an initial value of ωc in the simulated controller based on a bandwidth requirement derived from a transient response;
• and
• varying ωc in the simulated controller until one or more of, a simulated control signal increases beyond a noise threshold, the simulated control signal exceeds an evenness threshold, or an instability indicator in the simulated controller rises beyond a stability threshold.

A method for producing a PID controller, comprising:

• identifying a plant signature for a plant for which a PID controller exists;
• identifying an existing PID controller appropriate for controlling the plant based on the plant signature;
• and
• programmatically scaling the existing PID controller to a desired controller.

A method for producing a controller, comprising:

• identifying a known controller in a controller class where the known controller controls a first plant;
• identifying two or more scaleable parameters for the controller;
• programmatically relating the two or more scaleable parameters to a single scaleable controller parameter;
• identifying a desired controller in the controller class, where the desired controller controls a second plant that is frequency related by a frequency relation associated with the single scaleable controller parameter to the known controller;
• establishing the frequency relation between the known controller and the desired controller;
• and
• scaling the known controller to the desired controller by scaling the single scaleable parameter based on the frequency relation.

A method for tuning a controller, comprising:

• identifying a single tunable parameter for a controller to which two or more other tunable parameters for the controller can be related;
• programmatically relating the single parameter to the other tunable parameters;
• and
• programmatically varying the single tunable parameter until a desired controller performance is observed.

A set of application programming interfaces embodied on a computer readable medium for execution by a computer component in conjunction with frequency scaling a controller, comprising:

• a first interface for communicating a controller information;
• a second interface for communicating a plant information;
• and
• a third interface for communicating frequency scaling information derived, at least in part, from the controller information and the plant information.

In a computer system having a graphical user interface comprising a display and a selection device, a method of providing and selecting from a set of data entries on the display, the method comprising:

• retrieving a set of data entries, each of the data entries representing one of a frequency scaling choice for scaling a known controller to a desired controller;
• displaying the set of entries on the display;
• receiving a data entry selection signal indicative of the selection device selecting a selected data entry;
• and
• in response to the data entry selection signal, initiating an operation associated with the selected data entry.

A computer data signal embodied in a transmission medium, comprising:

• a first set of instructions for identifying a plant signature for a plant;
• a second set of instructions for identifying a controller class for a controller that controls the plant;
• and
• a third set of instructions for scaling the controller based, at least in part, on the plant signature.

A data packet for transmitting frequency scaling data, comprising:

• a first field that stores a known frequency for a known controller;
• a second field that stores a desired frequency for a desired controller;
• and
• a third field that stores a frequency scaling data computed from the known frequency and the desired frequency.

A method for auto-tuning a controller, comprising:

• identifying a plant Gp(s) and a nominal controller Gc(s,ωc) for the plant to be tuned;
• programmatically determining k and ωp for the plant Gp(s) and the controller Gc(s,ωc);
• programmatically determining a new controller for a new plant {overscore (G)}p(s)=kGp(s/ωp) according to {overscore (G)}c(s,ωc)=Gc(s/ωp, ωc)/k;
• and
• programmatically varying ωc for the new plant until a desired behavior is observed.

A method for adaptive self-tuning a controller, comprising:

• identifying a plant {overscore (G)}p(s)=kGp(s/ωp), where k and ωp are subject to change during plant operation;
• programmatically estimating, in real-time, k and ωp for the plant {overscore (G)}p(s);
• programmatically determining when the performance of the controller for the plant {overscore (G)}p(s) is degraded beyond a pre-determined, configurable threshold;
• programmatically updating the controller according to {overscore (G)}c(s,ωc)=Gc(s/ωp, ωc)/k;
• selectively decreasing ωc if dynamics of the plant deviate significantly from a model kGp(s/ωp) causing a performance problem or a stability problem;
• and
• selectively increasing ωc, subject to one or more ωc-optimization constraints, if the model can be updated to reflect one or more changes of the plant beyond k and ωp.

A method for automatically designing and optimizing ADOAC, comprising:

• if a model of a plant is available, accepting a mathematical model of the plant in one or more of, transfer function, differential equation, and state space form;
• if a model is not available, accepting a step response data;
• selectively accepting a non-modeled dynamic data;
• accepting zero or more hardware limitations;
• accepting zero or more software limitations;
• accepting one or more design requirements;
• selectively indicating whether a control law should be provided in a difference equation form;
• accepting a control law preferred form data;
• verifying a design feasibility by evaluating one or more of the mathematical model, the step response data, the non-modeled dynamic data, the hardware limitations, and the software limitations in light of the design requirements;
• selectively determining an ωc parameterized solution in one or more formats based on the design feasibility verifying;
• and
• producing one or more parameterized solutions of one or more different kinds, orders, and/or forms, as references.

A system for designing a controller, comprising:

• a plant data store that stores plant information;
• a controller information data store that stores controller class information and controller scaleable parameter information;
• a controller identifier that identifies a controller that controls a first known plant, where the controller has one or more scaleable parameters;
• and
• a controller scaler that scales the controller identified by the controller identifier to a scaled controller suitable for controlling a second, frequency scale related plant based, at least in part, on one or more of the controller class information, the controller scaleable parameter information, and the plant information.

A method for optimizing controller performance based on tuning controller bandwidth ωc, comprising:

• selecting an initial ωc value;
• programmatically altering ωc one or more times to one or more altered ωc values;
• electronically examining a controller performance at the one or more altered ωc values;
• and
• programmatically selecting a final ωc value from the initial ωc value and the altered ωc values based on the controller performance.

A system, comprising:

• a plant;
• a controller for controlling the plant, where the controller can be tuned on a single, frequency scaleable controller parameter;
• an observer for observing the controller, where the observer can be tuned on a single, frequency scaleable observer parameter;
• and
• a tuner for tuning the controller based on the single controller parameter and for tuning the observer based on the single observer parameter.