linux mint代写-EEE6207
时间:2021-02-07
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 program-
ming 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 computer-
based 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
#include
#include
#include
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 ex-
ploiting 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
TheAssignment Part 1: What is required is a means of updating the controller functionwithout
stopping the controller program. Thus the first part of the task is to modify the above C pro-
gram 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 demon-
stration, 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 in-
struction 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























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 program- ming 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 computer- based 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
#include
#include
#include
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 ex-
ploiting 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
TheAssignment Part 1: What is required is a means of updating the controller functionwithout
stopping the controller program. Thus the first part of the task is to modify the above C pro-
gram 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 demon-
stration, 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 in-
struction 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

学霸联盟


essay、essay代写