EEE6207 – Assignment – 2020/21
P. Rockett
12th December 2020
Note
This assignment will almost certainly require you to do some searching to identify suitable
methods of solving the problem(s). The Linux API—the system to be used here—contains so
many functions that it is impossible to learn all the details. Therefore, real systems programming
frequently involves looking through the documentation. However, by this stage in the
course, you should understand enough about operating systems to narrow your search down
to the relevant OS features.
1 Introduction
Computers are increasingly being used in control applications. Consider the case of a computerbased
controller where the system generates an updated control input every 10-15 minutes—in other
words, this is a real-time controller, but the time scale is not computationally very demanding. Such
systems are common in, for example, chemical engineering where the characteristic response time of
a physically massive chemical reactor is very slow due to inertia.
Looking at the simple example program below, the main program comprises an infinite loop
(since control is ongoing). The value of the input to the control variable u is determined by a simple
function called control function that takes the time index t as an input. Notice that in this trivial
example, the printf statement mimics sending the value of u to the plant at which point the process
sleeps for some period equal to the update time for the controller—maybe 10-15 minutes might be
used in practice for a large, slowly-responding plant1
.
// Example controller program — pir

include <stdio.h>

include <stdlib.h>

include <math.h>

include <unistd.h>

int control_function(const unsigned k, double* u)
{
*(u) = sin((double)k / 50.0); // Calculate input to plant
return 0;
} // control_function()
1More elegantly, the process should calculate the absolute time in the future when the next control output needs to be
calculated, and set an alarm for this time. In this way, if the calculation of the control signal takes a significant amount of
time, the sampling interval is held truly constant. But the simple sleeping solution is adequate here.
1
int main()
{
unsigned t = 0;
double u;
while(1)
{
if(control_function(t, &u) == -1)
{
printf(“control_function failed\n”);
exit(-1);
}
printf(“%lf @ %u\n”, u, t); // Mimics applying controller input u
to plant
t++; // Increment time index
sleep(1); // Sampling time… maybe 10-15 minutes in practice
}
return 0; // Should never reach here!
} // main())
Note: The control function here is trivial. . . in fact, it’s not really a controller at all! This
assignment is not about control rather the effective implementation of computer control by exploiting
operating system concepts.
In practice, it is often necessary to update the control function function to accommodate
changes to the plant characteristics, modifications to the plant operating protocols, etc. The simplest
way of doing this would be to stop the controller program, replace it with an updated program, and
restart the program. But stopping the controller is undesirable—the (brief) loss of control can cause
product loss or deviations. Also, some industrial processes are unstable so removing control—even
momentarily—can have bad consequences. Finally, the control program may be running on a small
embedded computer that does not even have a terminal so any updates need to be made remotely.
©P.Rockett, 2020 2
The Assignment Part 1: What is required is a means of updating the controller function without
stopping the controller program. Thus the first part of the task is to modify the above C program
to:

1. Change the function called within the infinite loop to some a completely arbitrary
   function; the function prototype, however, should remain unchanged. As a demonstration,
   you can use something like a function almost identical to the existing
   control function but one that calculates u = 2.0 * sin((double)k / 20.0)
   although this is just a simple example—in practice, the new function could be absolutely
   anything.
2. The controller program should only make this change when instructed to do so by an
   external command; having the controller program read a user input with a scanf instruction
   or similar is not an acceptable way of initiating the update—the controller may
   be running on an embedded computer with no terminal.
3. To conform to good programming practice, your solution should include appropriate
   error checking and all possible recovery mechanisms. For example, if your procedure
   to substitute a new controller function goes wrong for some reason, the existing
   function should continue to be used so that the plant is still under control. This may
   no longer be optimal, but it is better than the control of an exothermic chemical process
   ceasing at 4am on a Sunday morning!
   Assignment Part 2: Unless you are very lucky, the output of the new control function will not
   be equal to the output of the old control function at the point of switchover. This may result
   in the plant being subjected to an abrupt step input, which is highly undesirable for a number
   of reasons. It is therefore normal when switching between controllers to avoid such a step (or
   ‘bump’) in the control inputs by implementing so-called bumpless control. Instead of changing
   control algorithms abruptly, the action of the new controller is gradually introduced by using
   a system input of:
   u = λunew + (1 − λ)uold
   where the value of λ is gradually increased from 0 to 1 over some number of time steps—say,
   10—and thereafter the old controller’s output is ignored. This has the effect of‘fading in’the
   action of the new controller and‘fading out’the old one to achieve a bumpless transition.
   Further modify the above program to implement a bumpless transition when you introduce
   the new control function; demonstrate that you have achieved this with a suitable plot of
   controller outputs covering the switchover between controllers clearly indicating the point at
   which the new control function was made active.
   (Strictly, bumpless control is not really an operating system topic so this section just‘tidies
   up’the program; for that reason, it attracts a fairly low proportion of the marks.)
   ©P.Rockett, 2020 3
   Report Submission
   • This assignment will contribute 25% to the overall module mark. (You will need to pass each
   of the three assessment elements, of which this is the first, to successfully pass the course.)
   • The report should comprise up to 4 pages of A4 submitted via the EEE6207 course page on
   Blackboard by 8
   th February 2021.
   • You should discuss the design alternatives and trade-offs you have considered, and justify your
   final choice. These reasons might include, for example, that your preferred solution was simpler
   to code (and therefore less likely to contain bugs). Or maybe that your solution makes it
   possible to also do x, y and z.
   • The report should include your code—or at least sufficient of it to fully demonstrate your implementation,
   as well as evidence that it actually works. (A screen grab of the terminal output
   may be adequate.)
   • Part 1 will be worth 80% of the total marks—45% of which will be awarded for the design and
   discussion of design alternatives, and the remaining 35% for describing and demonstrating a
   working program.
   • Part 2 will be worth 20% of the report mark awarded for describing and demonstrating a program
   that implements bumpless transition between controllers.
   • On the subject of code, wud U. rite th:E Boddiy OF /ˆthe ripport lYke thiSS? No? So why
   would you submit a program written like this? See the interesting article on Technical Debt
   (https://www.parkersoftware.co…
   -should-you-do-about-it/). That students frequently submit difficult-to-follow code that
   is totally devoid of comments is probably understandable—‘success’in a programming assignment
   is seen as getting the program to work. End of story. But a properly presented program
   makes it clear to me what you have done, how you have done it, and therefore makes it easy for
   me to award you marks! If you force me to work through contorted logic with variables named
   ‘d’,‘dd’,‘ddd’, etc.
   2
   , I may fail to grasp your ingenious, working solution to the problem, and
   award a low mark because I cannot understand what you have done. Core principle: always
   help the examiner to award you marks.
   2
   I once had a colleague—now no longer in the department—who would write Fortran programs in which the first
   variable was named d’(for data). If he needed a second variable, he would call it‘dd’. A third variable would be called
   ‘ddd’. And so on. I really wish I was making this story up. . .
   ©P.Rockett, 2020 4