EEEN20011代做、代写C++编程语言

日期：2023-11-30 11:04

EEEN20011 Microcontroller Engineering II

Dr L A Marsh and Dr P N Green

Lab Task 4 (40 Marks)

In this lab task you are expected to use the joystick, LCD screen, speaker, both potentiometers and

the RGB LED on the Application shield. These are shown in the diagram below:

This task is designed to integrate many of the peripherals and programming techniques that you

have learned about so far on the course. It also requires you to implement a state machine in C++,

for which there are two example programs available that you may wish to study.

In this task you are required to make use of the LED, and Potentiometer Classes provided in

“Example Program 5: Creating a finite state machine and using TimeOut APIs”. You should not

modify the Potentiometer class. EITHER: The LED class should be used unchanged, OR you may use

your RGBLED class from task 3.

You should create a class called SamplingPotentiometer which inherits from the class Potentiometer.

This class should make use of a Ticker object to regularly execute the member function sample() in

the class Potentiometer. The constructor for this class should accept the pin name, the VDD for the

analogue input and the sampling frequency as parameters, as shown in Listing 1. The constructor

should configure and attach the Ticker callback to trigger the sampling process at the specified

frequency.

class SamplingPotentiometer : public Potentiometer {

private:

float samplingFrequency, samplingPeriod;

Ticker sampler;

public:

SamplingPotentiometer(PinName p, float v, float fs);

};

Listing 1: SamplingPotentiometer Class declaration for Task 4

You are required to implement a simple state machine using an enum as a means of defining a

program state. There are examples of this type of operation in “Example Program 4: Example of a

Finite State Machine to control program states”, and “Example Program 5: Creating a finite state

machine and using TimeOut APIs”. For this task you should implement the state machine within the

main() function, as shown in Example Program 4. The format should be similar to that shown below

in Listing 2.

typedef enum {state1, state2, state3, … staten} ProgramState;

//Definition of the enum that refers to the states of the program

ProgramState state;

int main()

{

while(1) {

switch (state) {

case (state1) :

//Code for this state

break;

case(state2) :

//Code for this state

break;

default :

//Default if not matching other state

}

}

}

Listing 2: Architecture of a simple state machine using an enum

In this type of operation your program can do different tasks according to the current state of the

program. You can, and should, use more memorable names for each of your states. Some

suggestions that you might wish to use for your program are:

initialisation, set_time, current_time, world_time, stopwatch, countdown_timer,

You are likely to need more states than this, but the above list should give you some idea as to how

you can implement a state machine to fulfil the requirements of the task. Bear in mind that you will

want to loop in some states, but may want others to only do something once, change state and

move on in the next iteration of the loop.

You should implement a Clock class that represents the functionality that your clock requires. A

suggested format is shown below, though you may wish to expand on this to include the world clock

functionality should you find this easier.

class Clock

{

private:

int time_hour, time_min, time_secs

public:

Clock(){}

void reset()

void tick()

void setClock()

int getHours()

int getMins()

int getSecs()

};

Listing 3: Example Clock class structure.

Your Speaker class from Task 1 should be updated to include member functions for toggling the

output, and returning the status of the output, if this has not already been implemented. The

Speaker class should have the same format of that shown in Listing 4 below.

class Speaker {

private:

DigitalOut outputSignal;

bool state; // Can be set to either 1 or 0 to record output value

public:

Speaker(PinName pin);

void on(void);

void off(void);

void toggle(void);

bool getStatus(void);

};

Listing 4: Speaker class format including toggle()

The toggle member function should be called from a Ticker API, where the time period should be

provided as part of the attach function. You should consult lecture notes and Mbed examples for

attaching member functions as a callback (ISR). You are free to choose an appropriate audible

output frequency.

You will need to implement some of the functionality from previous tasks, such as interrupts to

enable you use any required buttons on the joystick. Your ISRs should all be simple functions that

refrain from calls to computationally intensive operations, or blocking functions such as wait(). Your

ISRs should be used to switch the program on to the next state, or to update simple variables.

Some variables or objects may need to be declared outside the main function as global variables.

This should be avoided unless strictly necessary, and the use of all global variables should be

carefully justified.

You should use the LCD screen to display different data depending on which state the program is in.

You should avoid calling lcd.cls() in a loop – which can cause flickering, I’d recommend implementing

a filled rectangle of no colour to overwrite any data on the screen, or overwriting existing text as this

will be flicker-free. There will no doubt be other ways to implement this functionality, and as long as

your screen is updating smoothly then this won’t be a problem.

You should also use the RGB LED as a means of indicating the state some aspects of the program. It

should show the following:

Off: No timers running

Flashing Green: Countdown timer running

Blue: Stopwatch running

Please note that as per the video, both LEDs can be on simultaneously, with corresponding colours

visible.

You should be able to use the potentiometers to set the time during the relevant states; minimum

and maximum values should be contained to be within permitted ranges dictated in the video. The

potentiometers should also be used to navigate time zones with the minimum and maximum values

representing the cities furthest to the west and east respectively. A list of time zones will be

provided on Blackboard for you to choose from, and more details are available in ‘Marking

Requirements’ overleaf.

Where you are required to use the buttons on the joystick you should use the InterruptIn API and

attach appropriate callbacks. You are likely to need to attach different callbacks depending on the

required functionality of the button, which will change depending on the program state;

alternatively, you may have a single callback which checks the existing state of the program in order

to determine what the next state should be. Each approach is equally valid.

Your final program should display the same functionality as that shown in the example video on

Blackboard. Marks will be awarded for smooth operation of the program. So please ensure that

updates to the LCD screen are free from flickering, LEDs illuminate correctly, and button actions

perform the correct actions in each state.

Marking Requirements

The program required for this task demonstrates a significant amount of functionality, including user

input and a variety of outputs including LEDs and the LCD screen. As such the marking requirements

dictate that in order for full marks the final program should show all of the functionality described in

the video, as well as the essential criteria documented below:

The program should contain:

? The Class SamplingPotentiometer which should inherit from the Potentiometer class. This

class should automatically sample the analog inputs at periodic intervals and store sampled

values as data members of the class. The latest samples should be accessed by member

functions, as described above. You should take care to select an appropriate sampling

frequency.

? An object of type Ticker in the SamplingPotentiometer class.

? A class Clock which represents the functionality of a 24-hour clock in the format HH:MM:SS.

? A world clock which implements at least 20 time zones from -11 to +12 hours relative to

GMT. The ‘home’ city must be in the GMT time zone and can be a city of your choosing –

either ‘Manchester’ or ‘London’ are suggested but you are free to select another city in this

time zone. At least one city must have a non-integer offset e.g. +5h30 mins. You may choose

your cities from the list available on Blackboard.

? Objects of type InterruptIn for buttons of the joystick

? An object of type C12832. This will need to be imported – please see the guide on

Blackboard for using the LCD screen.

? Objects of type LED to allow for the illumination of LEDs that matches those described in this

document. You may also use your RGBLED class from task 3 if you wish.

? A number of ISRs/Callbacks which are called when your interrupt events occur (e.g. button

presses or timer events). These ISRs should be as efficient as possible and should be used to

change program state, or update global variables.

? You will need to declare some of the above objects outside of the main() function so that

they are in scope for your ISRs. You will need to carefully think about which of these will be

needed, and to appropriately justify all global variables that are used in your program.

? Implementation of a state machine that is able to represent the various states that your

program is in e.g. Initialisation, ClockSet, WorldTime etc.

Your main function, int main(), should contain code capable of:

? Declaring all necessary objects and variables which are only needed in the main function

? Implementing a state machine which can be used to control the flow of the program

? Setting the program in a suitable initial state

? Recovering from undefined states that might occur through the implementation of a

‘default’ case e.g. returning to the default state

Important notes (continued on the next page):

You will be expected to fully explain how your program works in order for marks to be awarded.

There will be marks available for your ability to answer questions relating to your program’s

implementation.

Your program must compile to be assessed. If you cannot implement the entire functionality without

compilation errors then consider if you can implement some of it in a stable version of the program

so that you can gain some marks.

Important Notes (continued):

The implementation of this program is expected to differ significantly between students. As such all

students must upload their source code via Turnitin for plagiarism checking. Lab marks will be

provisional pending this plagiarism check, and any suspected cases of academic malpractice will be

referred to the Department for investigation. There is a guide available on Blackboard which details

this process; please ensure that you are familiar with it before the lab session, and check with staff in

the assessment labs if there are any problems.

This is an in-lab assessment, and no late submission will be permitted. If you do not submit your

work for assessment in your scheduled lab, AND correctly upload your code for plagiarism

checking before the end of the session you will receive a mark of zero for this task.

A suggested workflow is provided below which you may wish to follow to ensure that this program is

implemented in logical stages. Though you may wish to undertake this task in a different way that

makes best sense to you:

1. Implement the class for a SamplingPotentiometer and verify that this works in its own

program.

2. Implement a basic clock that starts from 00:00:00 and counts sequentially.

3. Add code for setting this to arbitrary values and test the clock counts correctly from there.

4. Implement either the countdown timer or stopwatch timer in a program on its own.

5. Experiment with a simple state machine e.g. that uses a button to transit between

different states with a clear output. For example, illuminating a different LED for each

state or displaying a different message on the screen.

6. At this point you should write a brief plan of what your program needs to do. Usually for

state machines a flowchart is appropriate, but any alternative method would be suitable.

This plan will make it much easier to implement the program in stages and test more

gradually.

7. Bring together the clock, and timing functionalities into distinct states.

8. Add the more advanced features.

9. This is a complicated program, and you are strongly recommended to build it up in stages

and debug each stage separately. You are likely to find this task very hard to accomplish if

you develop large parts of it at once and don’t test in between, as it will be hard to track

down where errors are occurring.

This task is the most difficult of the four tasks. The main advice is to take things in stages,

and to remember that you can get marks for achieving some of the criteria, without having

to achieve them all. If you can’t do the full program perfectly, then do as much of it as you

can, as well as you can.

Application Shield Schematic

https://os.mbed.com/cookbook/mbed-application-shield