I enjoyed the class and got good grades, but I've never had to use it in practice.
Now I work for a tech company in Taiwan who make microSD cards, and some of the programming projects I worked on involved writing drivers for the testing machines. That was called "automation and control", but it's all been in software.
I like hardware, but I really don't know how to get back into it after 7 years in software.
Mind you that was a a few years back!
Advanced Control techniques like MPC are generally applied on complex plants such as chemical plants. In chemical plants, systems are slow but complex (highly multivariate with many interactions), so more complex optimal control techniques like MPC have a larger payoff. MPC has to solve an numerical optimization problem at every iteration, and requires more computational horsepower (not to mention prior mathematical modeling from step test data).
But even in chemical plants, the local loops are PID (actually, PI... D is rarely used). The MPC layer optimizes an objective function and sends setpoints to local PI loops to carry out control.
Of course, in Masters programs, you are already expected to know basic PID control.
Graduate courses that cover PID control tend to focus on intricacies like loop pairing, RGA, etc. PID control is an eminently practical field of study, and has many interesting facets like bump transfers, split range control, etc. There's a lot to learn about PID control that is non-theoretical.
First rule is you will not need any derivative except in a handful of particular cases that are well known/identifiable.
Google Books link → https://books.google.co.in/books/about/Control_Systems.html?...
Real world example: imagine you have a single-axis motion stage driven by electric motor and you want to control position of a carriage.
Usually your control output is motor voltage. Motor voltage approximately translates to current through motor windings, which in turn approximately translates to torque exerted by motor.
Torque exerts a force (T = F * r) on carriage. Applying force to the carriage makes it accelerate (F = m * a). Acceleration linearly increases the carriage velocity (v = v0 + a * t). Carriage having some velocity finally causes the position change (s = v0 * t + a * t^2).
In the essence, the system turns out to be non-linear with the respect to parameter you are controlling.
To improve this system, one solution is to add velocity sensor (or differentiate the position sensor, if it's resolution is high enough) and introduce a cascading PID loop topology- the outer loop takes position error and outputs velocity error, which is fed to inner loop (input = velocity error, output = acceleration). The coefficients for the loops have to be tuned starting from innermost loop.
Another solution is to use different control algorithm which is suited for non-linear systems (e.g. LQR).
Apart from being easier to tune, I just found a good article for why this approach works better for problems such as this. For quadcopters, of course, this allows one to easily switch between rate/acro mode and angle mode.
Each integrator is one dimension of state.
The nice thing about linear systems is that almost every dynamical system is locally linear near some operating point.
Maybe it's explained by the state space containing more terms than PID controller, so the transfer function can be linear for each individual term?
Given a linear plant model and a PID controller, you can compute all the classic control metrics like phase and gain margins, settling time, and even how the controller would perform according to the LQR metric.
That's the theory. All linear. Theoretically it's as appropriate to apply LQR to a nonlinear plant as it is to apply PID.
If you tweak the four LQR matrices (say, for a second-order system), and couple the gain matrix with the output of a linear observer (Luenberger), that combination system should be able to generate any PID controller. It's an over-parameterization, however (which is why I think PID controllers are ubiquitous. Not many parameters). Many settings will produce the same controller.
If anyone knows a reference that discussed PID and LQR like this, I'd love to see it
But as noted in my comment above, linear controllers can be used to control nonlinear systems under certain circumstances.
p.s. btw, having more states in the model does not linearize a nonlinear system per se. Only nonlinear transformations like log-transforms are capable of linearizing a system.
In practice, PID is applied to nonlinear systems too. The catch is the nonlinear system need to either be:
1) locally linear within the region of interest (very often the case)
2) mildly nonlinear
3) linearizable (by doing a mathematical transformation)
The first time I build a fuzzy logic controller for an industrial plant optimisation I was very surprised at performance vs complexity and how imprecise the characterisations can be and still get very good results.
I suspect the difficulties you've experienced stem not from nonlinearity, but from trying to control a system poorly approximated by a second order system with a second order controller. By cascading, both PID controllers effectively "see" a plant that looks more or less second order, so the controllers are much more effective.
Solutions to linear ODEs are in general exponential or polynomial in time. The solution doesn't have to be linear for the system to be linear.
(Unless I've misunderstood and you are modeling the system as actually controlling time. But I doubt that's what you meant)
The biggest issue for me was spending a lot of time trying to achieve a better system response (fast settling time with minimal overshoot) for system that was just designed badly.
Additionally, the set value for the boiler temperature is calculated using separate model that takes the group head temperature into the account.
The end result is that the controller is able to stabilize immediately, with maximum power of the heater and with no overshoots or undershoots to a temperature that takes into the account the state of group head to provide the ideal water when brewing.
While PID is able to control the temperature very accurately I found even in best case it took additional 50% of the time to stabilize and also it was difficult to optimally use 100% power of the heater until last possible moment.
Being able to achieve stability almost immediately means I can keep lower water temperature in the boiler and bring it to temperature at the last possible moment. End result being that it is now much faster to get it ready.
From my experience it is often observed in large processing plants that the operators have learned to do this instinctively from the standard faceplate.
I have slapped together few components to create a working prototype, STM32 Nucleo board with STM32L452 MCU, Texas Instruments development board with Bluetooth 5, some RTD temperature measurement development boards from MaximIntegrated, a bunch of relays, current sensors, water
flow sensor from Digmesa (actually replacement part from one of Saeco machines), etc.
I am using a test board to detect existing espresso machine operation and perform readings using multichannel laboratory thermometer that measures external boiler case temperature, group head temperature, brewing water temperature (inside portafilter), tank water temperature and external temperature along with signals (when the brewing starts, stops, etc.) to provide experimental data to build the model.
I am using Matlab and Simulink to help me generate parts of the software using gathered experimental data. This lets me play with models and observe how it could behave without actually brewing any coffee:)
Predictors are often too hard in practice, but in this case seems simple as looks like you have the parameters you need to calculate the required energy as Q=ml (+losses) and just put exactly that amount of electrical joules into the heating element.
"Tune" factors like thermal losses by hand, and/or have a simple heuristic learning algo that tunes factors for you based on previous result errors.
I am assuming you have the level in the tank as well to calculate volume, as how else do you protect the boiler element from coming on when no water in the tank?
Predictor calculates future evolution of the system based on current state and system parameters. The horizon changes dynamically and typically is about 5 seconds when in steady state and up multiple minutes when cooling from steaming to brewing temperature (depends heavily on insulation, steaming temperature, how long it was steamed, etc.)
The parameters are not directly physical values like thermal mass or energy but are related to them. For example, I am calculating the amount of energy lost based on water temperature and outside temperature (outside is inside enclosure). This is in units used to drive the heater (the unit is half-cycle of AC power). I am calculating (predicting) cooling of water when it is pumped based on amount of water pumped and temperature of water in the tank (this is also being measured).
I calculate initial values based on step responses and then use moving horizon estimator to continually test past predictions vs actual readings and adjust parameters to match.
I haven't yet analyzed which parameters are truly important and which can be easily compensated for without having to sense them.
As to the level of water in the I could not find suitable sensor so I built one. It can only give low level alarm (water falling below set level). It is a plastic pipe with floating magnet attach to the inside of the tank. On the outside, not mounted to the tank so that I can freely remove the tank, but pressed with a flat spring are two reed switches. Using those reed switches I can detect when water falls when its being used or when it rises when it is replenished.
Also sorry, I should have said Q=mcdelta(t) in my post.
My research of mods that are described on the Internet shows that most people put some kind of existing PID controller, SSR to control the heating element and a temperature probe which gets mounted on the outside of the boiler.
Minority is using Raspberry Pi, Arduino or some other kind of existing microcontroller board to allow for nice display and more functionality.
Few people are doing completely custom boards which is what I am doing for this project. I am currently learning electronics after almost 20 years in software and I find it very good exercise from design perspective.
We were given something almost identical to this, and the customer wanted a control algorithm. I had taken control theory, but there were two problems:
1. A lot of undergrad control theory assumes linear systems.
2. They almost always give you the transfer function.
Our system was likely nonlinear and we had no transfer function.
For simple physical systems, you can use basic physics to derive it. For anything else, figuring out the transfer function is a whole course in itself. I went to the control theory professor and asked for tips and he said "Forget it, it's way beyond the scope of a senior design project. I have students who do it for their MS project". Unfortunately, I couldn't convince the course's professor, and my grade suffered.
Oh well, you learn more in failure and all...
2. Yes, but the transfer function is usually only to simulate the system in Simulink or some such software. In the real-world, you never have the transfer function.
So how do people do it?
You either identify the transfer function model using step/impulse tests (covered in undergrad courses and not that hard to do -- the least sophisticated way is to just measure the response to a step and graphically estimate parameters K and tau; it gives you a good starting point), or you can tune a controller by hand starting with a tuning heuristic and then refining.
More advanced ways of identifying the transfer function is to collect data (either using pseudorandom binary sequence, i.e. PRBS step tests, or just simple plant step tests) and then doing "system identification", that is, fitting a transfer function model via statistical methods. Matlab's System Identification toolbox is designed for this purpose.
I suspect your course professor did not specialize in control, and/or doesn't have real world experience. This is not unusual of course. Faculty are often assigned courses to teach, and some of these courses are outside their area of expertise.
This is what I tried (step, not impulse). Did not work well. The result was too dependent on the "starting position".
The course professor probably knew less about controls than I did. He was a computer engineering professor.
PID controllers always control around a nominal operating point (which you pick), which is why deviation variables are typically used in the mathematical derivation. That's just the basis of the control algorithm.
Through personal suffering while working on firmware for UAVs (PX4/Ardupilot), CNC controllers (grbl, Marlin), inverted pendulum balancing exercises, RC car control etc.
Sadly, no resources. I guess the best advice I could give on this subject is: increase the visibility of internal state of the system. I have lost track of number of times I've seen people trying to tune PID controller just by outside observation (hmm, looks a bit better than last time) instead of real-time plots of measured process error.
Add high-resolution logging, look at the plots of error and P/I/D terms, have a simulation where you can replay the sensor values and observe the system output.
Without data we're just somebody with an opinion. It should be the root of our decisions.
The first time I encountered an explanation of how PID worked that made sense to me, was via the Udacity CS373 course that I took in 2012 (Thrun also had a great explanation on how a Kalman filter worked as well). This explanation of PID was repeated when I took the Udacity Self-Driving Car Engineer Nanodegree (starting in 2016).
In the CS373 course, Thrun detailed a few different ways to tune a PID controller - but one way he covered was rather curious in how it worked. It wasn't perfect, but it got you "close enough". I'm not sure if it would work well for a "real system" but for the purpose of learning it seemed to work well enough.
He called it "twiddle" - I don't know if he was the original author of it, or what - but here's a video that describes how it is implemented and how it works:
It's actually pretty neat - and the concept can be applied to virtually any algorithm in which you are trying to minimize an error amount.
Sure, you need cut off the noise with hardware in respect to your Nyquist frequence but you can still have a lot of high frequency noise.
And it is not always possible to use hardware filters to get rid of the noise, for example if your are tracking an object with a camera and the x,y is your input to the pid. Ofcourse you can skip the D part.
What am I missing here?
I also find it more easy to use a reset based integrator anti-windup, where you specify your limits on your control signal instead of limiting the integrator.
Here is an diagram of what I usally do:
-y | 1 | | |
-------->+ ------ +---------->+ Kd*s +----+
| 1+s*Tf | | | |
| | +------+ v
+--------+ +----+ +-+-+ +-------+
e=r-y | | | | | __ | u
--------+------------>+ Kp +----------->+ ∑ +---+-->+ __/ +---+--->
| | | | | | | | |
| +----+ +-+-+ | +-------+ |
| ^ | |
| +----+ +---+ +-----+ | | +---+ |
| | | | | | 1 | | | - | | + |
+-->+ Ki +-->+ ∑ +--->+ - +-----+ +---->+ ∑ +<----+
| | | | | s | | |
+----+ +-+-+ +-----+ +-+-+
| +----+ |
| | | |
+------+ kt +<-------------------+
Does some one knows the pros and coins with the different anti-windup solutions?
However, I typically do not change the state of the integrator the way you are doing here. I just hold the integrator state (i.e. don't update it) if the controller is limited. That way, noise on the P or D signals doesn't cause my integrator state to hop around. I may do it your way if the controller limits are changing over time for some reason.
I also always low-pass filter the D term, as you mentioned. Otherwise, the D term is just too noisy.
I often find that my P and D terms are limited by how much sensor noise I'm willing to let thru to my controller output.
No matter how much I read about the topic, I just could not grok it. The whole "state update" algorithm and sheer amount of different variables threw me off. Does anyone else feel the same way?
What worked for me in the end, was to first understand state observers (e.g. Luenberger observers) and then consider a Kalman filter as an optimal observer, where the observer gain is the steady-state Kalman gain.
The whole duality between state-feedback design and observer design -- and LQR and Kalman filters. Then it made sense :-)
Imo it starts with the name, it tells nothing and probably implies something different. It is the dynamic programming of control theory.
If you'd like a discount code (not worth the full price if your a SW eng) DM me on Twitter as I'm not sure I'm allowed to post it here.
When I did my MSc I did all my PID controllers in MATLAB/Simulink but since the actual code for a PID controller is very simple, it's easy to implement in Python or C++.
For implementing a PID loop, you can do it in pretty much any language you want -- it's relatively straightforward once you know the math. You can even do it in hardware via an analog circuit if you desire. However MATLAB / Simulink are commonly used when experimenting with system parameters due to the presence of straightforward plotting tools and numerical ODE solvers.
All of my own experience in controls (both as a student and professional) uses MATLAB/Simulink to model and generate controller code. Other tools are out there, but I don't know much about them.
My use case: I have this home-build growhouse that I use to start my seedlings in at the end of winter (and as a fermentation chamber for wine). It's controlled by a Raspberry Pi and as inputs I have 4 groups of LED grow lights, a 30w heating element, a fan that draws warm air out of the box and thus brings the temperature within the box towards ambient temperature, and DHT22 sensors that measure temperature and humidity inside and outside the box. The goal is to keep temperature as close to a certain target temperature as possible, keeping in mind that I want the lights to be on for a certain nr of hours per day and the lights give off so much heat that they will pretty much always make the temperature go over the target (so the fan then needs to bring it down again). It's easy to get this working the naive way with an hysteresis of say +/- 2 degrees (which is fine for my purposes), but the nerd inside me sees it as a game to make that band smaller. So I've been reading up on PID controllers and dear baby jesus I can't even work out how I'd get started. So the pragmatic part of my brain goes 'just run it for a few weeks with incremental inputs between 15 and 35 degrees (C, of course), measure the responses, toss all measurements into R and derive some regression parameters'.
Does anyone do this in industry? Probably not because everywhere I've asked, everybody's who's ever done real work on this uses PID controllers - but is that because they're easier to build on microprocessors (i.e., need less number crunching)?
Yeah that's a bang bang controller. Those actually work really well as long as you don't mind the temp swing.
It mostly sounds like your temperature control is via the fan and the heating element.
The heating element is the simplest to control with a PID loop. Just use a PWM output to control the heater power. Use a solid state relay to switch the power to the heater.
Once you have that you need someway to record and plot the setpoint and temperature.
Once you have that simplest way to get started is just play around with straight proportional control. Then add integral control with some sort of anti-windup. You don't actually need much theory to implement and tune a PI controller.
Three bits. For your case you likely only have to run the control algorithm at 10Hz. Second when tuning don't adjust your tuning constants linearly, instead double or halve them. On a Raspberry Pi use double precision floating point.
Finding good Kp, Ki, Kd gains by just sampling the [Kp, Ki, Kd]- space at random and trying it out on the real system is often not recommended. Firstly, because the state space is relatively large. Secondly, many systems can fail catastrophically if they become unstable, causing potential harm to man and machine. The second objection does not apply to a wine fermentation chamber, as far as I can see.
The powerful idea is the linear system model or the stochastic linear system model. Understand them and the properties of recursive filters and pid will come naturally.
The win is that someday you will end up needing either the stuff you learned or the math that you used, and you'll find out it's way easier (and more illuminating) learning it the second time around.
Actually, throughout he doesn't seem to acknowledge the different units between the P, the I, and the D, instead implicitly treating the whole system as discrete time for many purposes, in e.g. the recommendations for 100:1 ratios between P, and I; and D and P.
I took a course on this in college, and while that course mentioned the notion of sampling the D signal directly from feedback instead of from error, it never laid out why. This guide's practical explanation of why one might want to do that is great.
First, I am dithering the boiler power (the power is applied to the boiler on only some AC cycles), I am basically deciding per cycle whether I want my boiler turned on for the next 1/100th or 1/120th of the second. I am already running my model about 50 times per second (not using PID) so that's ok.
Being able to apply fractional power to the boiler means it is quiet and much less scale deposits.
Also due to the zero-crossing control I have much less electrical noise. Turning the boiler fully-on blindly causes electrical noise which is not nice for other devices (my Baratza Sette grinder turns on spontaneusly when this happens).
Dimming such heavy loads is not within spec in all jurisdictions though.
It also includes normal interval behaviour.
I am currently writing model-predictive controller with moving horizon estimator for my Silvia!
The idea of the controller is to model boiler water temperature based on current brew head temperature and previous heating/brewing history. Then the model-predictive part settles the boiler optimally, without any over/undershoots.
The estimator (general case of what is also called Kalman filters) monitors the operation to update model parameters. It is detecting the scale buildup over time! Kinda neat.
I also have a water level sensor which is a small plastic pipe mounted to the side of the tank. Inside it there is a floating magnet. On outside of the tank, there is a flat spring which pushes two reed switches to touch the side of the tank where the pipe is. This allows me to detect when water falls below acceptable level.
Potentially yes, but by it being a component of a completely different control paradigm (MPC). ML itself will probably not improve on PID while still keeping it PID.
So, there are two parts to a control system:
1) The predictive model (prediction)
2) The feedback control law (action)
ML primarily concerns itself with function approximation from data, y = f(x, p), where p are parameters -- in the parametric model case. ML practitioners create predictive models but don't really consider feedback loops. That is more the domain of control theory, which is concerned with system behavior when exogenous inputs (actions) act on the system. The math is different.
ML can be used to fulfill the role of (1). It has nothing to say about (2).
In the PID case, (1) is extremely simple -- it is simply an error function (difference). (2) is where the magic happens... based on the error, the controller computes the right action. The beauty of PID control is that it is technically "model-free" (if you don't consider an error function a model). You can apply it to systems where you have very little data, and still be able to do fairly good job. You could replace (1) in PID with an ML model, but then you would defeating one of the some of attractive qualities of PID control: effectiveness under uncertainty without a model. You can use ML to guide the tuning of PIDs, but that's about it.
That said, ML models have a place. In advanced controllers like MPC, (1) is typically a dynamic (state-space, FIR/FSR, physics equations-based) causal model of the system under control. (2) is an optimization algorithm.
You could conceivably replace (1) with an ML model. This is done in many cases -- in many plants, there is a predictive model that infer states based on images and sound (for instance, using Near Infra Red sensors to inferentially predict certain chemical properties). But that's no longer PID.
For a non-linear system, machine learning can perform much better and solve more complex tasks. Like walking for a humanoid robot. A linearzied PID solution can not beat that.
For linear systems:
Depends of what you mean with better I guess. My understanding is that you can place some of the poles of a system with a PID pretty much where you want. So for a simple linear system: no.
There exist also other controllers where a LQR can be used in linear systems to get a perfect theoritical controller based upon to minimize the cost of control outputs. (yes, several outputs).
However maybe a ML can be used to choose and tune the controllers better than humans?
Also, the discretication is not always perfect (backward or forward euler is common estimates). So maybe ML can help in that too?
Right but you are comparing a nonlinear regression model with a linear control scheme, which isn't really fair. Plenty of nonlinear control strategies exist and are used in practice for things like humanoid walking. Moreover, many people prefer these controllers due to the theoretical guarantees they provide over a learned control policy.
That said, ML does have a place in control theory, and you can find papers going back to at last the 90s (I never looked earlier but they probably exist) that combine the two, and not just in a reinforcement learning context.
> However maybe a ML can be used to choose and tune the controllers better than humans?
Probably not, assuming you are discussing linear systems. You would need to come up with some cost function for your ML algorithm to determine the performance of a particular control policy, but then why not just use that as the objective function for your optimal control algorithm?
I have made this mistake before, and the sometimes strange control behavior can be frustrating. Considering the small performance penalty for using doubles on modern hardware, it is excellent advice.
If you don't have time or knowledge to do that, floating point works better because you can be more ham-fisted with your scaling and still not overflow or saturate.