联系方式

  • QQ:99515681
  • 邮箱:99515681@qq.com
  • 工作时间:8:00-21:00
  • 微信:codinghelp

您当前位置:首页 >> C/C++编程C/C++编程

日期:2021-01-04 11:26

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.com/blog/what-is-technical-debt-and-what

-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


版权所有:编程辅导网 2021 All Rights Reserved 联系方式:QQ:99515681 微信:codinghelp 电子信箱:99515681@qq.com
免责声明:本站部分内容从网络整理而来,只供参考!如有版权问题可联系本站删除。 站长地图

python代写
微信客服:codinghelp