INTRODUCTION:

In this week's tutorial you will extend the functionality of the

reaction$-$time game you built in Tutorial $11.$

Before attempting the tasks below, copy the contents of the following

files from your finished Tutorial $11$ project:

$-$ src$/$buzzer$.$c

$-$ src$/$timer$.$c

$-$ src$/$tutorial$11.$c $($this file$)$

This week you will implement the following commands that will be

transmitted via UART:

$-$ S$1$: via $\text{'}1\text{'}$

$-$ S$2$: via $\text{'}2\text{'}$

$-$ S$3$: via $\text{'}3\text{'}$

$-$ S$4$: via $\text{'}4\text{'}$

$-$ INC$\_$FREQ: via $\text{'}.\text{'}$

$-$ DEC$\_$FREQ: via $\text{'},\text{'}$

$*/$

void state$\_$machine$($void$)$;

int main$($void$)$

$\{$

cli$()$;

adc$\_$init$()$;

button$\_$init$()$;

spi$\_$init$()$;

pwm$\_$init$()$;

timer$\_$init$()$;

uart$\_$init$()$;

sei$()$;

state$\_$machine$()$;

$\}$

void enable$\_$outputs$($uint$8\_$t value$)$

$\{$

$\}$

void disable$\_$outputs$($void$)$

$\{$

$\}$

typedef enum

$\{$

GENERATE,

PROMPT,

INPUT$\_$WAITING,

INPUT$\_$RECEIVED,

INPUT$\_$EVALUATE,

DISPLAY$\_$SUCCESS,

DISPLAY$\_$FAILURE

$\}$ state$\_$t;

void state$\_$machine$($void$)$

$\{$

disable$\_$outputs$()$;

$//$ Player input

uint$8\_$t input $=0$;

$//$ Player reaction time

uint$16\_$t reaction$\_$time $=0$;

$//$ Pushbutton state

uint$8\_$t pb$\_$previous$\_$state, pb$\_$current$\_$state $=0$xFF;

$//$ Pushbutton edge flags

uint$8\_$t pb$\_$falling$\_$edge, pb$\_$rising$\_$edge $=0$x$00$;

while $(1)$

$\{$

$/**$ EX: $12\mathrm{.}0$

There is no simple mechanism to measure the duration of a

keypress when receiving UART inputs S$1$ to S$4.$ Therefore, when

providing feedback for inputs S$1$ to S$4($via the pushbuttons or

UART$),$ ensure that the corresponding outputs are enabled for at

least the playback delay.

TASK: Extend the state machine you built in Tutorial $11$ to

accept alternative inputs via UART.

The gameplay commands S$1$ to S$4$ correspond to pushbutton inputs

S$1$ to S$4,$ respectively. Use the variable "uart$\_$input" from

"uart.c$"$ to access the current UART input command.

When no UART inputs are received or after a UART input has been

processed, you should set "uart$\_$input" to $4.$

$*/$

$/**$ CODE: Write your code for Ex $12\mathrm{.}0$ within this while loop. $*/$

$//$ Values used to write to the TCA$0.$SINGLE.PERBUF register.

#define TONE$1\_$PER $0$

#define TONE$2\_$PER $0$

#define TONE$3\_$PER $0$

#define TONE$4\_$PER $0$

static uint$8\_$t selected$\_$tone $=0$;

static int$8\_$t octave $=0$;

$/**$ EX: $12\mathrm{.}1\mathrm{.}1$

TASK: Declare a static global Boolean variable "buzzer$\_$playing" to allow

the buzzer frequency to be updated while the buzzer is playing.

$*/$

$/**$ CODE: Write your code for Ex $12\mathrm{.}1\mathrm{.}1$ above this line. $*/$

$/**$ EX: $12\mathrm{.}1\mathrm{.}2$

TASK: Extend the "buzzer$\_$on$"$ and "buzzer$\_$off" functions to modify the

variables "buzzer$\_$playing" and "selected$\_$tone".

Also, update the logic in the "buzzer$\_$on$"$ function to adjust the

frequency of the buzzer output based on the static global variable

"octave".

HINT: An octave is a doubling or halving of frequencies, and frequency

is inversely proportional to period.

$*/$

void buzzer$\_$on$($const uint$8\_$t tone$)$

$\{$

static const uint$16\_$t base$\_$periods$[4]=\{$TONE$1\_$PER, TONE$2\_$PER, TONE$3\_$PER, TONE$4\_$PER$\}$;

$\}$

void buzzer$\_$off$($void$)$

$\{$

$\}$

$/**$ EX: $12\mathrm{.}1\mathrm{.}3$

TASK: Implement the functions "increase$\_$octave" and "decrease$\_$octave"

to modify the static global variable "octave". If the buzzer is playing,

these functions should also update the buzzer frequency accordingly.

The octave should be limited to the range $-2$ to $2.$

$*/$

void increase$\_$octave$($void$)$

$\{$

$/**$ CODE: Write your code for Ex $12\mathrm{.}1\mathrm{.}3$ within this function. $*/$

$\}$

void decrease$\_$octave$($void$)$

$\{$

$/**$ CODE: Write your code for Ex $12\mathrm{.}1\mathrm{.}3$ within this function. $*/$

$\}$

$/**$ EX: $12\mathrm{.}2\mathrm{.}1$

TASK: Declare a variable "uart$\_$input" to store the current UART input to

the reaction$-$time game. This variable will be used by both the main

state machine and the UART receive interrupt. Make sure to add this

variable to the header file "uart.h$".$

When no input is received, the variable should be set to $4.$

$*/$

$/**$ CODE: Write your code for Ex $12\mathrm{.}2\mathrm{.}1$ above this line. $*/$

ISR$($USART$0\_$RXC$\_$vect$)$

$\{$

$/**$ EX: $12\mathrm{.}2\mathrm{.}2$

TASK: Handle the following serial commands as they are received via

UART:

$-$ Characters $\text{'}1\text{'}$ to $\text{'}4\text{'}$ should modify the variable "uart$\_$input" to

corresponding numeric values to be used by the main state machine.

$-$ The character $\text{'},\text{'}$ should increase the octave of the frequencies

produced by the buzzer.

$-$ The character $\text{'}.\text{'}$ should decrease the octave of the frequencies

produced by the buzzer.

$*/$

$/**$ CODE: Write your code for Ex $12\mathrm{.}2\mathrm{.}2$ within this function. $*/$

$//$ Read received data and clear interrupt flag

char rx$\_$data $=$ USART$0.$RXDATAL;

$\}$