ABSTRACT

The goal of this project was to create a more realistic and interactive appliance interface for a Usability Science class here at Union. Usability Science deals with

how easily a user can accomplish certain tasks and evaluating how usable certain designs are. The purpose is to replace the previous cardboard, ad-hoc

interfaces with something that allows students to test their designs for usability more efficiently. The goal of our research was to design and create both the

software and hardware implementations of a system that allows students to plug in any of many “widgets” (I/O devices) onto a main board in any location and

then let the student specify in software how the widgets are supposed to interact with each other. Using a microcontroller, the board will also record when and

how each widget was used so that the usability of a certain design can be determined. Designing the most modular and flexible way to create the hardware

widgets along with an easy to use and modular programming language have been focal points of the project. The design has moved from connecting wires, I/O

devices, and chips together on a protoboard, to prototype devices, to printed circuit boards with all the components in place and a programming language that

allows a user to define a state machine for a design.

A Pedagogical Tool for Usability Science

Senior Project - Computer Engineering - 2009Nickolas Potvin

Advisors: Professors Hedrick, Cass, and Fernandes

BACKGROUND

Many of the design choices for this project were previously decided by

another student so one of the main goals for us was to follow the designs

already in place. The designs in place and future designs also have to

coincide with the overall design goal to create a product that is modular and

allows for a more usable simulation of an appliance. This means that all

designs have to function in tandem with the microcontroller chosen for this

project: the TINI by Dallas-Micro. The TINI is a Java enabled

microcontroller that also has support for the 1-wire devices developed by the

same company which are location independent due to their addressability.

In addition, the TINI is Ethernet-enabled so all code updates and testing can

be done through telnet or FTP.

SOFTWARE DESIGN

In order to design any software to use the TINI microcontroller and get these

widgets to function, we had to explore the individual chip functions and use

them in a Java program. The chips we used for this project are the DS2450

(A/D converter) for input and the DS2413 (2-channel switch) for output.

Both chips have their own unique

functions and every chip has a unique ID

number used to identify it on the 1-wire

bus. Each device’s ID number is stored

in a database after I’ve created the widget using that device. After a user

has created a program using my specific language created for this project,

that program gets parsed into a tree, that tree gets broken down into a data

structure, that data structure has specific values filled in from the database of

known devices, and that data structure can then be used to fill in a template

Java program to be used on the TINI.

FUTURE WORK

As of now, there are difficulties fitting some of the desired designs on to the

given space requirements for each widget. Further research into the use of

PIC chips is required in order to fit a clock (four 7-segment displays) or

another complicated device onto one widget. The software also has much

more work that needs to be done before it can be fully functional. In

addition to storing information about each widget in a database, the program

needs to save time-stamped data about each widget that is used while a

program is running and be able to dump that data log at any point. The

software also needs to easily allow each widget’s functionality to be tweaked

for each user so that different boards can be designed.

WIDGET CREATION

The first picture here (left) shows one of the prototype widgets I have

created that is a 7-segment display that uses four DS2413 chips. The second

picture shows another finished widget made using printed circuit boards.

This second widget (middle) uses a potentiometer to act as a knob and a

DS2450 chip. Both widgets were created using a solder reflow process that

involves a special solder paste and the use of an oven to solder small chips.

This design can be easily reproduced and simply plugged into the main

board, which can be seen below (right). This prototype board only allows

four widgets to be plugged in simultaneously but has the exact same

functionality of a larger final board.

WIDGET DESIGN

After we decided on the initial hardware

design, we needed a more efficient way

to create each widget. We were

able to transfer the previous hardware

design into CAD Eagle (top). After all

the parts are on the schematic in Eagle

it is a simple matter of making

connections where they are needed.

A board file is then created in Eagle,

which specifies the exact locations of

each part and wire (middle). Once we

have finished the board file, it is

exported to CircuitCAM, which allows

us to prepare and convert the design for

the circuit board printer. We can then

use the circuit board printer to create the

designed circuit using a collection

of drilling and milling tools (bottom) on

the LPKF rapid prototyping machine.

The finished product (after quite a bit of

soldering) can be seen in the “Widget

Creation” section.

RESULTS

Not only have we created a design that allows the widgets to be location

independent and interchangeable but we have also created several fully

tested and implemented widgets. Two widgets have

been fully tested and four have been designed. A

prototype main board has also been created to allow

the widgets to interact just as they would on a larger

version. I have also made notable progress on a user

scripting language that defines how widgets behave.