Module 8: Interaction State Machine

9.2 Design and Implementation

The operations in the specification can all be performed using a simple circular buffer, operating as a stack. In a stack the first element on is the last element off, conceptually one can consider a stack of plates, we can either add a plate to the top of the pile, or remove a plate from the top of the pile. The difference is that we require some form of wrap around. These operations can all be performed in labVIEW using two variables, the first is an array of fixed length that allows us to store elements, and the second is an index into that array that stores the next location to write to.

Since we wanted to store many variables of different types we decided that the one unifying variable type was the string, the array of elements was therefore to become and array of strings. The index is simply an index into an array and so should be of type integer.

The basic operations of the data logger, as described by the specification, is to read and write elements (Strings), thus we also need to define a “mode” that the buffer is to operate in. This mode is inputted into the buffer as a string, there also needs to be a “data in” input and a “data out” output, also of type string. The modes used are

1. 
   “read”: This is when we wish to pull an element off the stack, the element appears at the output “data out” and is removed irretrievably.
   
2. 
   “write”: This is when we want to add an element to the stack, the element added is whatever appears at the “data in” terminal.
   
3. 
   “initialise”: This is necessary before performing any “read” and “write” operations, as it initialises the array with a set number of elements and also sets the internal index variable to refer to the start of the buffer. This mode can also be used as a reset, when we wish to clear the buffer for any reason.
   

The buffer is of limited size, and is internally set to hold 200 elements.

For this buffer to be useful it needs to behave in a cyclic manner, so that when the array becomes full the index wraps around and references the oldest element, this is done using the modulus, or modulo function, shortened to ‘mod’.

And to step forward:

Now that we have the basic functionality of the circular buffer we can build additional functionality around it. We created a shell to encapsulate the circular buffer that acted as an error handler to deal with spelling mistakes on the “mode” input.

We also wanted to be able to access the stack in its entirety without effecting the operation of it. This was to incorporated another mode, a “file dump” mode that outputs whatever is in the stack and writes it to a text file. To do this we added an additional output to the basic circular buffer (BCB) that outputs the array. We also needed access to the internal index of the BCB for reasons that will become apparent.

The array that the BCB now outputs is not useful to us when writing to a file, this is because the first element in the array is not the most recent element. The most recent element is located at the position before (including wrap around) what the now outputted index is referring to. To write to a file in a useful form, we require the most recent element to appear at the beginning of the file. In order to achieve this we have to split the array at the index and shuffle the two split arrays around a little, we then have an array with the most recent string appearing as the first element and older strings appear in chronological order after that. This array is called “stack chorological” and is an output of the shell encapsulating the BCB.

The shell still has the same “data out” and “mode” terminals that behave the same as the BCB does.

The shell has effectively two “data in” terminals; these are labelled “variable name” and “variable value”, and are of type string. These two inputs effectively form the “data in” entry to the BCB with some additional information attached. The format for the string actually stored is:

Variable Name: “name” Value: “val”

Where “name” and “val” are the inputs to the circular buffer. So for example:

Variable Name: 2D prism Array Size Value: 1

9.2.4 To String vis

As the circular buffer required strings inputs we had to write numerous toString vis that converted the information that we were currently storing in .ctl files into a suitable and meaningful string representation.

9.3 Testing

Although this is not an exhaustive test it does indicate the wrap around effect and overwriting of old elements, as well as the ordering of “stack chronological”. To save space and time the size of the stack was reduced to 5 elements, to improve clarity the time stamp added is just abbreviated to , the “Variable Name:” has been abbreviated to “VN” and “Value:” has been shortened to “Val”

Variable Name	Variable Value	Mode	Data Out	Stack Chronological	Expected
Do we care	no	initialise	VN: Do we care Val: no	“” “” “” “” “”	Yes
First	1	write	VN: First Val: 1	VN: First Val: 1 “” “” “” “”	Yes
Second	2	write	VN: Second Val: 2	VN: Second Val: 2 VN: First Val: 1 “” “” “”	Yes
Third	3	write	VN: Third Val: 3	VN: Third Val: 3 VN: Second Val: 2 VN: First Val: 1 “” “”	Yes
Fourth	4	write	VN: Fourth Val: 4	VN: Fourth Val: 4 VN: Third Val: 3 VN: Second Val: 2 VN: First Val: 1 “”	Yes
Last One	Check	write	VN: Last One Val: Check	VN: Last One Val: Check VN: Fourth Val: 4 VN: Third Val: 3 VN: Second Val: 2 VN: First Val: 1	Yes
Over write	one	write	VN: Over write Val: one	VN: Over write Val: one VN: Last One Val: Check VN: Fourth Val: 4 VN: Third Val: 3 VN: Second Val: 2	Yes
Over write	two	write	VN: Over write Val: two	VN: Over write Val: one VN: Over write Val: two VN: Last One Val: Check VN: Fourth Val: 4 VN: Third Val: 3	Yes

9.4 Future Work

Our file writing implementation is not ideal, the user is always prompted for a location to save the log to. A Boolean button on the main GUI could be added that writes the log to file upon pushing of the button.

9.5 Final Specification

The final specification of this module, while no functionality has been removed from the initial specification, is decidedly different from that initial specification. The added functionality includes error handling, file writing, and the presence of a time stamp on the stored variable. These functional components were added as it was deemed necessary for implementation into the final overall programme.

9.6 Documentation

Figure 53

This vi is the shell that encapsulates the BCB and builds the additional functionality, including error handling, into the BCB.

Inputs	Type	Description
Variable Name	String	The name to attach to the data value, used only in “write” mode
Variable Value	String	The data value as a string to store, used only in “write” mode
Mode	String	The mode that the buffer operates in, can be “read”, “write” or “initialise”.

Outputs	Type	Description
Stack chronological	String array	An ordered array so that the most recent element to be written to the stack is the first element in the array, and older elements appear in chronological order after that
Data out	String	In “write” mode data out contains what is being stored in the stack, for “initialise mode” then data out contains what would be stored on the stack, given Variable Name and Variable Value if the mode was “write” however no write action is performed. If the mode is “read” then data out contains the most recent element of the stack, and that element is then shifted to the bottom of the stack.