ECE 477 Final Report Spring 2008 Team 11 RoboRubik€¦ · ECE 477 Final Report Spring 2008 -1- Abstract The following information in this report will describe the design process

ECE 477 Final Report − Spring 2008 Team 11 − RoboRubik

Team Members: #1: ___Erik Carron_______________ Signature: ____________________ Date: _4/28/08_ #2: ___Dave Bukiet_______________ Signature: ____________________ Date: _4/28/08_ #3: ___Tyler Heck________________ Signature: ____________________ Date: _4/28/08_ #4: ___Casey Kloiber______________ Signature: ____________________ Date: _4/28/08_

CRITERION SCORE MPY PTS Technical content 0 1 2 3 4 5 6 7 8 9 10 3 Design documentation 0 1 2 3 4 5 6 7 8 9 10 3 Technical writing style 0 1 2 3 4 5 6 7 8 9 10 2 Contributions 0 1 2 3 4 5 6 7 8 9 10 1 Editing 0 1 2 3 4 5 6 7 8 9 10 1

Comments: TOTAL

ECE 477 Final Report Spring 2008

-ii-

TABLE OF CONTENTS

Abstract 1

1.0 Project Overview and Block Diagram 1

2.0 Team Success Criteria and Fulfillment 2

3.0 Constraint Analysis and Component Selection 3

4.0 Patent Liability Analysis 8

5.0 Reliability and Safety Analysis 10

6.0 Ethical and Environmental Impact Analysis 12

7.0 Packaging Design Considerations 16

8.0 Schematic Design Considerations 18

9.0 PCB Layout Design Considerations 22

10.0 Software Design Considerations 24

11.0 Version 2 Changes 27

12.0 Summary and Conclusions 27

13.0 References 28

Appendix A: Individual Contributions A-1

Appendix B: Packaging B-1

Appendix C: Schematic C-1

Appendix D: PCB Layout Top and Bottom Copper D-1

Appendix E: Parts List Spreadsheet E-1

Appendix F: Software Listing F-1

Appendix G: FMECA Worksheet G-1


-1-

Abstract The following information in this report will describe the design process leading up to the

completion of the RoboRubik project. RoboRubik is a Rubik’s Cube solver with the ability to

play in the same way as a traditional Rubik’s Cube and also give hints to the solution to a

scrambled cube. The details of all design considerations of the RoboRubik project are discussed

in the remainder of this document.

1.0 Project Overview and Block Diagram RoboRubik is a self-contained Rubik’s Cube solver consisting of a microprocessor-controlled

PCB with multi-colored LEDs under each cube face. A user interface is used to input the current

state of the cube via an embedded web server. A stored algorithm calculates the moves required

to solve a Rubik’s Cube from any valid starting position. The cube has two different mode of

operation. Help mode allows the user to follow the steps leading to the solution with RoboRubik

acting as a visual aid. Play mode gives the user the ability to solve the RoboRubik cube

manually using buttons located on each cube face. RoboRubik is shown in Figure 1-1 and a

block diagram of the RoboRubik design is shown in Figure 1-2 below.

Figure 1-1: RoboRubik Project


-2-

Figure 1-2: Block Diagram

2.0 Team Success Criteria and Fulfillment Below is the list of the team success criteria approved by the course staff. All five project-

specific success criteria were successfully demonstrated.

An ability to:

control the device state/configuration via an embedded web page

The wireless network device inside RoboRubik has a Java applet stored in memory

which allows the user to configure a Rubik’s cube to an initial state.

display “state” of cube via a series of integrated (multi-color) LEDs

Each cube face of RoboRubik has eight RGB LEDs allowing the device to display the

colors white, blue, red, green, yellow, and magenta by different RGB combinations.

change the “state” of the cube via a pushbutton on each face

The pushbutton located in the center of each cube face of RoboRubik performs a

single 90º rotation of the corresponding face of the pushbutton being pressed.


-3-

autonomously solve the cube from arbitrary (user defined) initial state

When the user switches to Help mode in the user interface, the solving algorithm

stored on the wireless network device calculates the moves needed to change

RoboRubik into the solved cube state.

provide “hints” when solving the cube in “manual” mode

Pressing the Step button located on the user interface while in Help mode shows the

user the next step leading to a solved cube.

3.0 Constraint Analysis and Component Selection Since the intention of the RoboRubik is to replicate a Rubik’s Cube in digital form, the

dimensions of RoboRubik are as close to an official Rubik’s Cube as possible. Therefore, the

size of RoboRubik’s packaging is a major design constraint. Due to the aim of constructing a

self-contained project, RoboRubik requires batteries for its source of power. Thus, power

consumption is also considered a major constraint. The final limitation is the on-chip memory of

the microcontroller since a stored program is used to calculate the moves required to solve the

cube. The design constraints of the RoboRubik project are discussed in detail in the remainder

of this section.

3.1 Computation Requirements

During initialization of the cube state, RoboRubik receives the information input by the user

from the user interface on a separate device. Once the data is received, the state of the cube is

represented on the cube via multicolored LEDs. The stored solving program is used to compute

the moves required to solve the cube. These moves are then saved to memory. In both Help and

Play modes, the user rotates each face by pressing the pushbutton on that respective cube face.

This causing the LEDs to change colors illustrating a rotation of the cube face, but the cube does

not physically rotate. In Help mode, the user steps through the stored solution by pressing one of

the face pushbuttons. In Play mode, the user manually solves the cube. Rotation of a single face

is accomplished by pressing the pushbutton on the respective face. The speed of

microcontrollers is more than sufficient for the application of pushbutton sensors, LED updates,

and other computations. Therefore, speed will not be a limiting design factor.


-4-

3.2 Interface Requirements

A user interface is used to input the initial state of the cube. A GUI Java applet is stored on the

wireless network device inside of RoboRubik and is accessed on an external computer for the

user to input the color of each of the cubes on each face. The data received by the wireless

device is then passed on to the microcontroller. The wireless network device communicates with

the microcontroller through the microcontroller’s on-chip serial interface [1]. The wireless

device runs at a 3.3V input requiring a DC-DC converter to step down from the 6V battery

source [2]. Also, an additional DC-DC converter is required to decrease the input source voltage

to 3.3V in order to power the microcontroller [1].

Pushbuttons located on each cube face instruct the microcontroller to perform tasks determined

by the mode of operation. The cube state is represented via LEDs under the cube face. Each

face contains eight LEDs and one pushbutton. Therefore, a total of forty-eight LEDs and six

pushbuttons are required. All of the LEDs on a single face are controlled by a 16-bit LED driver

IC. Each IC is capable of controlling sixteen LEDs [3]. A serial interface with the ICs is used to

input and output data. Three separate LEDs are integrated to form each multicolored LED.

Thus, two LED driver ICs are required to control the LEDs of each cube face.

3.3 On-Chip Peripheral Requirements

The Serial Communications Interface module of the microcontroller is used to communicate with

the internal wireless device of the cube. The wireless device requires a single channel of serial

I/O to interact with the microcontroller [5]. The Pulse-Width Modulation peripheral is used to

strobe the LEDs and output the state of the cube via the LED driver ICs. The microcontroller’s

Timer module samples the pushbuttons regularly to determine when they are pressed.

3.4 Off-Chip Peripheral Requirements

The 3.3V power source input of the wireless device and microcontroller require DC-DC

converters [5,1]. The LEDs on each cube face are controlled by LED driver ICs using a serial

interface with the microcontroller.


-5-

3.5 Power Constraints

Since the RoboRubik is a battery powered device, power consumption was taken into serious

consideration while designing. The large number of LEDs left two options for controlling the

output of the cube state. While the microcontroller is capable of operating all the LEDs, the

amount of output pins would require a much larger and more powerful microcontroller than

needed for this application. To achieve every color, 20mA of current is required [4]. Therefore,

the second option of using off-chip ICs was accepted. Utilizing the PWM, Pulse-Width

Modulation, peripheral of the microcontroller allows RoboRubik to strobe the LEDs. Strobing

the LEDs reduces the amount of time each LED is on decreasing the amount of current drawn

while remaining unnoticeable to the naked eye. With the LEDs remaining constantly on, the

entire circuit draws approximately 900mA of current. Strobing the LEDs with a 50% PWM duty

cycle reduces the current drawn to around 600mA, a reduction of approximately 33%. The

Energizer 2CR5 lithium/manganese dioxide battery produces a maximum continuous discharge

of 1500mA hours [22]. The DC-DC converter used to drop the supply voltage from 6V to 3.3V

is the only component dissipated an excessive amount of heat. Therefore, heat dissipation was

considered due to the small size of the RoboRubik, but it was deemed a minor concern.

3.6 Packaging Constraints

Each side of a Rubik’s Cube measures approximately 5.7cm across [6]. Due to the minimum

size of some major components, the size of each side of the cube container must be increased to

9cm, approximately 3.5”, for the RoboRubik design. Since the design is intended to be a

handheld/tabletop device, the packaging must withstand minor turbulence. Surrounding the

internal PCB structure of RoboRubik are thin cotton sheets acting as light diffusing filters as well

as a cushioning between the circuitry and RoboRubik’s external plexiglass shell. Silicone

sealant connects the six plexiglass segments together completing exterior of RoboRubik.

3.7 Cost Constraints

The RoboRubik is intended for entertainment and educational purposes. The Rubik’s Cube is

the major competitor of RoboRubik to be considered. With a MSRP of $11.99, the Rubik’s

Cube is much cheaper than the RoboRubik [6]. However, the additional functionality of multiple

modes and the digital aspect of RoboRubik make it more like a simple gaming system. Nearly


-6-

all prices of the components listed for RoboRubik are the result of a small order size.

Considering the reduction in cost of mass production, the overall price of RoboRubik would

decrease drastically to an estimated $190. This would make a simple educational gaming system

such as RoboRubik much more appealing to a family than one of the current gaming systems

which are much less educational and more expensive.

3.8 Component Selection Rationale

One of the major components considered was the wireless network device. The two devices

compared were the WiPort and MatchPort by Lantronix [7]. The purpose of the wireless device

is to communicate with the external user interface and the microcontroller. The two major

features differentiating the two devices are size and power consumption. The physical

dimensions of the WiPort and MatchPort are very similar [7]. However, the MatchPort requires

an additional antenna to be connected to the device for wireless transmission and reception. The

inactive power consumption of the devices is comparable [7]. While the active power

consumption of the WiPort is nearly twice that of the MatchPort, it was assigned a smaller

weight in terms of comparison since the amount of time the wireless device will be active in the

RoboRubik is small compared to the inactive state. Therefore, the deciding factor in the decision

to choose the WiPort was the size of the device. A comparison of the design constraint features

of the WiPort and MatchPort is shown in Table 3-1 below.

Part Size (mm) Range (ft) Power (mW) Memory (KB)

WiPort 33.9 x 32.5 x 10.5 328 indoors 750 active

300 inactive

2000 Flash

256 RAM

MatchPort 45 x 45 x 10.4 * 328 indoors 740 active

250 inactive

2000 Flash

256 RAM

* Requires additional attachment (antenna)

Table 3-1: Wireless Network Device Comparison

The other major component selected was the microcontroller. The two microcontrollers

considered were the MC9S12C32 and the MC9S12C128 by Freescale. The major difference


-7-

taken into consideration between these two microcontrollers is the size of on-chip memory. The

solving algorithm which calculates the solution to a Rubik’s Cube puzzle requires an extremely

large amount of code and thus a large amount of memory. The C32 has 32KB of on-chip Flash

and 2KB of RAM while the C128 has 128KB Flash and 4KB RAM [1,8]. Another difference

between these two microcontrollers is the price. The C128 is nearly triple the price of the C32

even when the items are purchased in bulk [1,8]. While the price difference points toward the

C32, the C128 was chosen as the microcontroller for RoboRubik due to its greater memory

capacity. A comparison of the design constraint features of these two microcontrollers and an

additional similar microcontroller is shown in Table 3-2 below

Part Size (pins) I/O (pins) Power (mW) Memory (KB)

9S12C32 48 LQFP 60 82.5 32 Flash

2 RAM

9S12C64 48 LQFP 60 82.5 64 Flash

4 RAM

9S12C128 48 LQFP 60 82.5 128 Flash

4 RAM

Table 3-2: Microcontroller Comparison

3.9 Summary

The major constraints of size, power consumption, and on-chip memory were taken into

consideration while choosing the components for the RoboRubik project design. The limiting

factor in the size constraint category was the wireless network device. The WiPort by Lantronix

was chosen due to its lack of additional components required. In the case of the power

consumption constraint, some sacrifices had to be made in order accommodate for other design

constraints which were not able to be compromised. The microcontroller chosen has more than a

sufficient amount of memory required to store the data necessary for the project. A complete

parts list is included in Table E-1 of Appendix E.


-8-

4.0 Patent Liability Analysis The RoboRubik project is one in which the Rubik’s Cube logic puzzle is replicated without the

moving parts but instead implemented with LEDs. RoboRubik has a user interface such that a

player may make all the same moves one could make on a regular Rubik’s Cube, but RoboRubik

has an additional feature to be able to solve any provided initial state of the cube. The main

purpose of this section is to provide information regarding any patent liability to be taken under

consideration when completing this product. The original patent filed by Erno Rubik for his

cube was in 1983. So worry about infringing on this patent can be minimized due to the fact that

this patent has expired some time ago. There are many products on the market today that utilize

the logic puzzle that Rubik did and there were a few patents that have slightly similar qualities to

the RoboRubik project. Even though this is true, the possibility for liability, even among all

these patents was found to be very slim.

4.1 Results of Patent and Product Search

In doing research on patents and products for which the RoboRubik might infringe on, it became

clear that the products currently on the market and the patents going through the reviewing

process made no direct claim to the puzzle game implemented in the Rubik’s cube. Every

product or patent was a way of marketing a specific version of the game or a new and inventive

game based on the same principles of the game. Take for example patent number 6,974,130 [9]

filed on December 13, 2005 called “Manipulable puzzle cube.” The abstract describes it as “an

improvement of the classic Rubik’s Cube,” where the goal is to create pictures on the sides

instead of return it to its original configuration. Their claims include the fact that their cube is

3x3x3 in size, but it’s hard to infringe on what is known in the geometric world as a “cube.”

Another patent, number 5,310,183 [10] filed on May 10, 1994, is called “Transparent cube

puzzle.” This patent’s abstract defines this product as in the most basic sense a see-through

version of the puzzle game of Rubik’s Cube. The argument being that users enjoy variety, the

clear sides provide a new entertaining way to enjoy an old puzzle game. The claims of this

product are very specific and include that the size sides must have specific indentations in them,

so the fact that our sides are made of a clear plexi-glass to see to the LED’s won’t be infringing

on this patent if the specific indentations are absent. Patent number 5,651,715 [11] filed on July

29, 1997, is yet another implementation of the Rubik’s cube but with another twist. According


-9-

to the abstract, the polygonal sections are held together by elastic rather than the typical axes.

This patent is not being presented as a liability threat so much as another sample of the large

amount of products implementing Rubik’s Cube uniquely and acquiring patents in the process.

4.2 Analysis of Patent Liability

In all of the aforementioned patents, there were similarities across the board. For all of these

patents to be allowed to exist, their implementations needed to be different. The concept of

spatial logic puzzles is not a new one, but the RoboRubik idea is completely revolutionary and

inventive. None of the patents that could be found during research implemented a Rubik’s cube

using only LEDs to represent the colored sides. In addition, every implementation of a logic

puzzle that could be found involved rotational parts about an axis where RoboRubik requires no

moving parts to partake in the game. The simple action of a button press causes our project to

spring to life and “rotate” the sides in a manner identical to the original Rubik’s Cube. There

may be some trademark infringement with including the name “Rubik,” but for our reinvention

of a classic game, patent liability is nearly non-existent.

4.3 Action Recommended

Despite the assertions made that there is a negligible chance of patent liability, this doesn’t mean

action is not in order. Of course there could have been oversights and specific patents relating to

RoboRubik could have been missed and also there is the chance of someone with a pending

patent identical to RoboRubik that has been recently filed. In any case, research on the subject

must be continued to insure that patent liability will remain at the level this research has shown.

4.4 Summary

The information provided in this section concludes the RoboRubik currently needs no revision in

its current state to attempt to avoid patent infringement. Many versions of Rubik’s Cube are on

the market but they avoid infringement through unique implementations. The implementation of

the cube through the use of software and LEDs without moving parts is extremely unique to the

current field of patents available. Research must be continued to assure no patents arise during

production of the RoboRubik.


-10-

5.0 Reliability and Safety Analysis Since RoboRubik is basically a toy, there are very little high criticality concerns with it. The

only possible way the user can be harmed from the RoboRubik is by the brightness of the LEDs

and a possible battery acid leakage. Both are very unlikely to happen, but possible. For

reliability, there are very little major components that can fail. These components do not work at

a high temperature which makes them less likely to fail. The components that will be

investigated are the microcontroller, the WiPort, the voltage regulator, and the LED drivers.

5.1 Reliability Analysis

For the reliability analysis, the components investigated were the microcontroller, the WiPort,

the voltage regulator, and the LED driver. All these components play a major role in the

functionality of the RoboRubik and they all operate at a temperature above room temperature.

The MIL-HDBK-217F military handbook was used to calculate the reliability of each of these

components. The coefficients selected and the reliability values are shown in Table 5-1.

Reliability Calculations

Component C1 C2 ∏T ∏E ∏Q ∏L λ MTTF Model

Micro 0.28 0.019 0.98 5.0 1.0 1.0 0.3694 2.7070 Microprocessor

WiPort 0.29 0.017 0.98 5.0 1.0 1.0 0.3692 2.7086 MOS Logic Array

Voltage Reg. 0.01 .0016 7.0 5.0 1.0 1.0 0.078 12.8205 Bipolar Linear Array

LED Driver 0.02 .011 0.98 5.0 1.0 1.0 0.0746 13.4048 MOS logic Array

Reference: MIL-HDBK-217F λ is in number failures per million hours

Table 5-1: Reliability Coefficients and Calculations

As you can see, the microprocessor and the WiPort are the most vulnerable. They both have

about 2.7 years between failures for every one million products. The other two have about 13

years between failures. This is acceptable for the RoboRubik because there is pretty much no

high criticality. There were several assumptions made when calculating these values. The first

was that all these products have been in production for over two years. Another was that each

device had a worst case scenario of having an operating temperature of 85˚C. The Environment

Factor was not exactly known so the average of 5 was used. The Quality Factor was also not


-11-

exactly known and neither was the class the components fell into so a value of 1 was used. As

far as the complexity of the components, the microprocessor used the 16-bit value. The WiPort

used the 30,000 to 60,000 MOS logic array. The Voltage Regulator used the 1 to 100 bipolar

linear gates. The LED driver used the 101-1000 MOS logic array. The package failure rate was

calculated with the nonhermetic package and the number of pins for each component. An easy

way to improve these reliability factors is to decrease the operating temperatures. The

temperatures are proportional to the amount of current each component draws so by decreasing

the current, the temperature goes down. This can be done by efficiently strobing the LED

drivers. Another way to improve operating temperature is by making sure the cube has enough

air circulation to dissipate heat.

5.2 Failure Mode, Effect, and Criticality Analysis (FMECA)

There are very little high criticality failures for the RoboRubik. As mentioned before the only

possibility to harm the user is by the LEDs being too bright and the battery leaking acid. There

are many possibilities for low criticality failures such as anyone the major components failing.

The two criticality levels are defined in Table 5-2.

Criticality Failure Effect Max Probability

L1 Eye damage or acid burns λ < 10-9

L2 Partial or no functionality λ < 10-6

Table 5-2: Criticality Levels

There are four functional blocks investigated for failure. They are the microcontroller block, the

WiPort block, the voltage regulator block, and the LED driver block. The schematics of these

blocks can be viewed in appendix A. The FMECA worksheet can be viewed in Appendix B.

5.3 Summary

The RoboRubik has a high reliability rate for being a toy. There is very little possibility to harm

the user, but possibility to unsatisfy the user due to functionality failure. The components that

can cause the L2 criticality level were within the specific failure rate of λ < 10-6. The

components that can cause the L1 criticality level were not within the specific failure rate of

λ < 10-9 , but they were close.


-12-

6.0 Ethical and Environmental Impact Analysis Being a toy, RoboRubik has been designed to be as safe as possible and including RoHs

compliant components as well as cutting down on power consumption were two major

considerations during the design process. The main ethical issue in any product is that the device

does not or will not cause any harm to the user. RoboRubik is not a dangerous device but if it

malfunctions, it could pose a danger to the user. These issues were kept in mind during the

design of RoboRubik. The environmental impact of RoboRubik is most noticeable when looking

at the number of printed circuit boards being used. With seven in total, all these boards require

the use of hazardous chemicals in order to produce them and these chemicals must be disposed

of properly. RoboRubik must also not cause undue harm to the environment once its lifecycle

has ended. This is addressed as well.

6.1 Ethical Impact Analysis

As mentioned above, RoboRubik was designed to be as safe as possible. The main pieces of the

design are our PCBs, which will be covered by a sheet of plexi-glass and pieces of paper to help

filter and spread the light, and our electronic components which are all attached to the PCB.

There are two possible ethical problems that could arise and both of them relate to the safety of

the user. In its normal usage, RoboRubik is very safe and poses no threat. However, it some part

of the design was to malfunction then a danger could come about. First, the LEDs being used

are incredibly powerful and can be hard to look at if running at full power. On the specification

sheet for the LEDs it has a warning not to look directly at them, saying “Do not look directly at

LED without unshielded eyes or damage to retina may occur” [13]. During normal operation the

LEDs will not be running at full tilt so there will not be a danger for retina damage, but a

warning label will be included, cautioning the user as to the possible danger. Strenuous testing

will also be done during the development phase to ensure that the LEDs operate at a level that is

not damaging to the eye but is bright enough so the user can distinguish its color.

The second ethical concern is that of the batteries being used to power RoboRubik. Nothing is

inherently dangerous about these batteries, but the danger of the power circuitry shorting is

present in any electrical device. In RoboRubik, if a short occurs and no power is being


-13-

dissipated then the batteries could rupture. They are lithium / manganese batteries and contain

hazardous chemicals like corrosive acids that could damage the user. With proper testing, any

possible problems can be identified and resolved before the product reaches the market. Many of

these lithium batteries contain fail-safe devices in them and can shut off the circuit if any

problems occur. As a precaution, a warning label is put in the documentation stating the

possibility of rupturing batteries.

There is another ethical concern that does not involve possible injury to the user and that is if one

of the hardware components fails or a bug is discovered in the code. The software concern will

hopefully be addressed during the development of RoboRubik and it will be produced without

any significant bugs. RoboRubik should be of good quality and last a long time and the best way

to ensure that is to choose components with a long lifespan and to test the product thoroughly

before it’s sold.

6.2 Environmental Impact Analysis

There are three main phases to the lifecycle of any product: the manufacturing stage, the normal-

use stage, and the disposal/recycling stage. The main components being discussed in this section

will be the printed circuit boards, the lithium/manganese batteries and the hardware components.

6.2.1 Manufacturing Phase

RoboRubik uses a total of seven printed circuit boards in its design, each one 3.4” x 3.4”. These

boards are not very large but with seven of them for each RoboRubik, the manufacturing of these

will definitely have an environmental impact. Any PCB created is going to contain a small

amount of lead along with other materials that are not good for the environment [15]. The

Restriction of Hazardous Substance Directive has stated that manufacturers must make efforts to

reduce six prominent chemicals in their printed circuit boards, lead being one of these [16].

During the manufacturing process a number of steps produce pollutants. After drilling, the PCB

is scrubbed to extraneous copper particles which are typically lost with the waste water. Near

the end of the process the PCB is etched to reveal the circuit pattern using an ammonia-based

solution. This is another pollutant that should be reduced.


-14-

It is always a good decision to choose a manufacturer that is environmentally conscience and one

that will strive to cut down on the hazardous materials used and disposed of during production.

Methods such as installing a water-chiller that re-circulates and reuses the chemical bath water in

PCB production can cut down on the hazardous chemicals released into local water sources [15].

Another thing that can be done in the concentration of chemical baths can be reduced to only

what is absolutely necessary for production. The copper particles lost after drilling can be

reclaimed and used in another batch of PCBs. Inefficiency and laziness are not excuses for using

processes that damage the environment.

As stated above, the batteries used in RoboRubik are lithium/manganese. These batteries are

widely used in electronics, have a long life and are very reliable. They are not rechargeable but

can be disposed of safely into a landfill. The hardware components chosen were all RoHs

compliant are not harmful to the user.

6.2.2 Normal Use Phase

The main environmental concern of the normal-use phase is use of non-rechargeable batteries.

The batteries can be disposed of in a landfill once they are fully discharged but it is ideal to cut

down on how often the user must get new batteries. The best way to reduce the power

consumption of RoboRubik is to reduce the current sourced through the LEDs. With 48 total, a

lot of current is going to be drawn so RoboRubik is designed to strobe the LEDs with a square

wave. This will significantly reduce the power consumption. The WiPort has the capability of

being set to different power states depending on the functionality required. The WiPort draws a

couple hundred milliamps of current in normal power mode. A low power mode would reduce

the amount of current drawn by the WiPort.

6.2.3 Disposal and Recycling Phase

Once RoboRubik has reached the end of its normal use phase, the product needs to be recycled

or disposed of properly. After a long life of use if RoboRubik is still in good working order, the

best option would be to give the device away, perhaps to a friend or sibling who has not had a

chance to play with the toy. If RoboRubik is not in working order then proper disposal and

recycling is imperative to ensure as little environmental impact as possible. Organizations such


-15-

as ICER, the Industry Council for Electronic Equipment Recycling, have a vast amount on

information of different companies that are committed to recycling as much of their electronic

equipment as possible [17]. Many of the metals on the PCBs can be retrieved and used again

such as copper, nickel, gold, silver and palladium [14]. Many of the hardware components can

be removed from the PCB and either broken down into base materials or refurbished and used

again in another product. Companies like Eastern Environmental Technologies specialize in

recycling printed circuit boards and all sorts of other electronic components [18]. Many old

PCBs in computers and CRTs cannot be thrown away without proper steps taken. Businesses

and institutions are not legally allowed to dispose of old computers in landfills or incinerators as

doing so could release dangerous chemicals into the environment. Eastern Environmental

Technologies encourages all businesses to take their old PCBs and computers to companies like

itself for proper disposal. They can remove some of the precious metals like gold, silver and

copper for reuse as well as quarantine hazardous chemicals. In doing so, the business knows it

won’t face possible litigation for environmental damage or health hazards. They also recover

some of their initial capital investment and qualify for a tax break.

6.3 Summary

As with any electronic device there are ethical and environmental issues that take place with the

creation of RoboRubik. It is intended to be a toy but even toys can have an impact on the

environment or have dangerous consequences for the user if precautions are not taken. The two

main ethical concerns of RoboRubik both revolve around possible harm to the user. Our LEDs

can possibly get too bright to look at and cause retina damage for anyone in the vicinity. The

possibility of this can be lowered through rigorous testing during development. The other ethical

concern is the possible danger of the batteries we are using. Any electronic device has the

capability for explosion of the circuitry is damaged but rigorous testing will make sure that

doesn’t happen. The environmental concerns are the same as any other electronic device.

RoboRubik contains seven printed circuit boards and manufacturing those boards requires the

use of hazardous chemicals. Cutting down on the concentration of the chemical baths used in

production is a major goal to strive toward. The user of RoboRubik should also properly dispose

of and recycle as many of the components as possible. There are a number of organizations

willing to recycle the PCBs and hardware components so they can be refurbished and put into


-16-

new electronic devices. Only by taking these steps can RoboRubik not impact the environment

more than is absolutely necessary.

7.0 Packaging Design Considerations The RoboRubik project is similar to a traditional Rubik’s Cube built not with moving parts, but

with LEDs and pushbuttons to represent all the sides of the cube as well as cube rotation. The

entire project is housed in a cube built using clear plexiglass so the LEDs can display the various

colors of the squares of the cube. The top side of the cube can be removed to turn the device on

or off and change the battery.

7.1 Commercial Product Packaging

The two commercial products found to be similar in design to the RoboRubik project are the

original Rubik’s Cube [19]and the newer Rubik’s Revolution [20].

Figure 7-1: Rubik’s Revolution Figure 7-2: Rubik’s Cube

Figure 7.1 on the left is the Rubik’s Revolution and Figure 7-2 to the right is the original Rubik’s

Cube. Both products used a packaging which displays nine cubes per face of a cube. The sides

of the Rubik’s Cube can be rotated whereas the Revolution’s sides cannot. The Rubik’s Cube

was the inspiration for the RoboRubik project, but with its LED centers and programmed

hardware contained internally, the Revolution is closer to the design chosen to implement.

Details on the products are presented below.

7.1.1 Product 1: Rubik’s Cube

The original Rubik’s Cube, as mentioned before, was the initial inspiration for the RoboRubik

project. The length of each face is 5.7cm per side made of hard plastic. There are three layers of


-17-

sides, each made up of nine individual plastic cubes. Each cube has stickers placed on it to

display the color of the side to which it belongs. The concept of the Rubik’s Cube game was

taken for the RoboRubik project, but instead of moving each cube face as the Rubik’s Cube,

LEDs change colors to simulate the rotation of a side. This product is very compact and the

portability aspect of the Rubik’s Cube was a constant consideration when constructing the

RoboRubik project. The issue with the Rubik’s Cube is the area in the center of the cube is

extremely limited allowing virtually no room for hardware.

7.1.2 Product 2: Rubik’s Revolution

The Rubik’s Revolution is a much larger product with an 11cm length per cube side and it is

much closer to the design RoboRubik was intended to accomplish. There are no moving parts

and the Revolution contains internal hardware which is fairly similar to the way RoboRubik

operates. Much like its Rubik’s predecessor, the Revolution is made up of nine cubes per side,

but the difference is the center of each side contains a pushbutton LED to help the user interact

with the games in the Revolution. The pushbuttons in the middle of each side is an aspect of the

Revolution which is implemented in RoboRubik to help interface with the user. The only design

problem with the Revolution is large in comparison to the original Rubik’s Cube to which the

RoboRubik design was intended to be closer in size.

7.2 Project Packaging Specifications

The RoboRubik project packaging is simple and straightforward. The six sides of the cube are

constructed out of clear plexiglass with a square hole cut out of the middle to allow access to the

pushbutton on each face [21]. Each of these side is connected to a PCB sections containing eight

LEDs and a single pushbutton. The six sides are connected together, one of which is connected

with magnets so it can be removed to access the interior of the cube. Inside the cube, another

PCB is used to host the microcontroller and other parts needed to complete the operation of

RoboRubik. The drawings in Appendix B give a better understanding of the orientation of these

PCBs. Figure B-1 gives a cut-away view of the interior of the cube illustrating the guts of

RoboRubik. Figure B-2 is an exploded view of one of the side PCBs showing the layout of the

pushbuttons and LEDs.


-18-

7.3 Printed Circuit Board Footprint Layout

Based on the major components chosen for this project, there are two different footprints. One is

for all the side of the cube and the other is for the internal components. There is only one way to

make a footprint for the sides since the project is dependent on the placement of the LEDs. The

LEDs must be placed in a square around the pushbutton and the LED controller is placed next to

the pushbutton. For the internal components, there needs to be enough room for the

microcontroller, the battery pack, and the embedded web server. The layout provided in

Appendix D displays the PCB footprint for both the main PCB, Figure D-1, and the side PCBs,

Figure D-2. The dimensions of each PCB are 3.4 inches by 3.4 inches for both main and side

PCB. Since RoboRubik requires one main PCB and six side PCBs, there are a total of seven

PCBs making up RoboRubik internal structure.

7.4 Summary

In this sections, the packaging design for RoboRubik was discussed. The other products having

similar packaging were shown to give insight into the considerations taken when designing

RoboRubik. There are several drawings in the appendices showing the packaging design in

more illustrative detail including sketches in Appendix A and PCB layouts in Appendix D.

8.0 Schematic Design Considerations The design of the schematic can be broken up into two subsections: the theory of operation and

the hardware design narrative.

8.1 Theory of Operation

The RoboRubik is comprised of four basic hardware subsystems: power, CPU, wireless control

and display.

8.1.1 Power

Much like a normal Rubik’s Cube, RoboRubik is handheld and compact, and much like the

Rubik’s Revolution, RoboRubik has a substantial battery life. The power options were limited

by merely how many batteries could fit into the cube. The Energizer 6V EL2CR5 lithium

battery has approximately 900 to 1200 milliamp hours [22]. Do to the large number of LEDs,


-19-

RoboRubik requires a large amount of current. It was found through testing that these batteries

were acceptable for use in RoboRubik.

Given that all components operate in the 3.3V range, these 6V batteries had too high a voltage to

handle. Therefore a voltage converter was necessary to step down the 6V input voltage. The

Fairchild KA278R33 LDO voltage regulator performed this task for us. It takes a wide input

range and outputs a 3.3V operating voltage [23]. One of these was placed at the start of the

circuit.

8.1.2 CPU

The RoboRubik CPU is a Freescale MC9S12C128MFAE 16-bit microcontroller. Commands are

sent to the microcontroller using a Serial Communication Interface (SCI) and stored on the

chip’s onboard memory. Subroutines that change the current state of the LEDs are called when

user input is received from the external pushbuttons or when the user requests a hint, via the web

server, as to the next move. The microcontroller is running off of an 8MHz crystal oscillator.

The PLL circuitry in conjunction with this oscillator causes the microcontroller to run at

approximately 24MHz. The microcontroller can be set to operate at a 5V or 3.3V range [24].

The operating voltage was set to 3.3V for two reasons. The first is that the Lantronix WiPort

operating voltage is also 3.3V [25], which means there was no need to amplify signals.

Secondly, the forward voltage of the green and blue components of the Optek RGB LEDs is

3.3V [13]. As mentioned before, by using a 3.3V operating voltage for the microcontroller one

voltage level

8.1.3 Wireless Control

The Lantronix WiPort Embedded Wireless Networking Device was chosen for the wireless

communication device. The WiPort provides TCP-to-serial communication between a user

interface website and the microcontroller. The WiPort includes a complete 802.11 b/g radio,

serial interface to external CPU or other device and 2MB of Flash memory for webpage storage

[25]. Upon initialization the WiPort’s serial port is coupled with a specific TCP port number.

This serial port is tied to the SCI port on the microcontroller. A static IP address is assigned to


-20-

the WiPort also upon initialization, which is receives from the DHCP server on a local WLAN

[26]. The WiPort and microcontroller were set up to communicate with a baud rate of 9600.

To begin using RoboRubik the user navigates to the homepage of the WiPort embedded web

server, which is located on the static IP address port 80 [26]. The homepage lets the user select

from different operating modes such as Play, Help, etc. Once the user has made a selection, that

command is placed on the WiPort web server IP:port [26]. The command is serialized and

transmitted on the TCP stack to the WiPort serial port where it is received by the CPU and

further computation takes place [26].

8.1.4 Display

The display subsystem consists of 48 LEDs (8 per side). The remaining square of each side is a

colored pushbutton. There are a total of 48 tri-color RGB LEDs. The RGB LEDs from Optek

Electronics contain one red, one green and one blue LED and can subsequently be light to create

a large spectrum of colors [13]. Six distinct colors are necessary for a Rubik’s Cube and are

created by signaling one, two or three LEDs at once. The six colors used were Red, Blue, Green,

Yellow, White and Magenta.

The LEDs are driven by a series of Allegro A6279 latched LED drivers. The A6279 can drive

up to 16 LEDs. For the design of RoboRubik the A6279 will drive 12 individual LEDs, or 4

RGB LEDs. There will be 2 drivers for each side of RoboRubik.

The LED drivers operate by receiving a serial input from the CPU as a shift register. Rather than

use the SCI for this, two I/O pins can be configured to represent the serial and clock signals. The

data is shifted down and the driver latches the value upon enabling [27]. When the display

requires updating, the serial data moves along the shift register every time the input clock goes

from low-to-high. Once the 16-bit value arrives, the data is for each shift register is latched upon

LATCH ENABLE signaled high. The latch data is then outputted upon OUTPUT ENABLE

signaled low. To specify which driver is to be updated, the serial data and clock signal are sent

to all 12 drivers and the LATCH ENABLE signal is multiplexed by a 4x16 multiplexer [27].


-21-

8.2 Hardware Design Narrative

The main subsystem of the microcontroller that was used was the Serial Communication

Interface and the Pulse-Width Modulator. The rest of the subsystems will be deactivated to

allow for more I/O pins to be used.

8.2.1 Serial Communications Interface

The SCI has two pins on the MC9S12C128MFAE: TXD and RXD [24]. TXD is the output pin

for the SCI and RXD is the input pin for the SCI. TXD is tied to the RXD0 pin on the WiPort

and RXD is tied to the TXD0 pin on the WiPort. This establishes a flow of communication

between the WiPort and the microcontroller, allowing commands from the web server to be

processed on the microcontroller and updates in the LED display subsystem to be sent back to

the web server.

8.2.2 Pulse-Width Modulation Subsystem

Since power consumption was a major design consideration, it was decided that the LEDs should

be strobed using the PWM to cut down on the consumption of power. The LED drivers

OUTPUT ENABLE pin is strobed with a 100Hz wave with a 50% duty cycle. This reduced the

power consumed by the LEDs without lessening their effectiveness.

8.2.3 Initialization Narrative

Once RoboRubik has been powered on and the user has navigated to the website, the

initialization can begin. The user selects from different operating modes depending on their need

of RoboRubik. This command is posted to a TCP port that is directly connected to the WiPort.

This hardware functionality is already built in. Once the command reaches the WiPort the data

is sent through the serial port to the microcontroller where a serial interrupt occurs. The interrupt

handler interprets the command and dispatches the necessary subroutine located in memory.

This subroutine computes what the most current display state should be and once it has been

fully processed; it proceeds to load the 12 LED drivers with this information. The output of the

LED drivers is enabled and the display now reflects the most current RoboRubik state.


-22-

8.2.4 Pushbutton Narrative

RoboRubik has been powered on and initialized and the user is free to play with the device.

They determine what their next move should be and press the corresponding pushbutton. Upon

pressing the button, the timer interrupt on the microcontroller that is monitoring the pushbuttons

detects a pushbutton event. The interrupt handler interprets the command and dispatches the

appropriate subroutine. The subroutine computes the next state of display and sends this

information to the LED drivers. The drivers are loaded with this new state and updated to reflect

the changes.

8.3 Summary

In this section of the report, the theory of operation and hardware narrative were discussed.

Design issues of size and power were taken into consideration and major subsystems of

RoboRubik were outlined. The major subsystems each have a specific purpose and must work in

conjunction with the others in order for RoboRubik to operate correctly. The schematic of

RoboRubik is shown in Appendix C.

9.0 PCB Layout Design Considerations

Our design project the RoboRubik, a digital Rubik’s Cube that uses LEDs to represent colored

blocks unlike a normal Rubik’s Cube that uses a mechanical system and colored stickers.

There are seven total PCBs in the RoboRubik, the main board and 6 side boards. Each face of

the cube has a PCB containing a pushbutton and eight LEDs to represent the multicolored blocks

of a normal Rubik’s Cube. The main board in the middle contains the “brains” of the

RoboRubik.

9.1 PCB Layout Design Considerations – Overall

The size of the cube was our main constraint. The main board contains the heart of the design.

It contains the microcontroller, the WiPort [29], the power circuitry, and the headers to the other

boards. The side PCBs contain the Optek LEDs [13], the Allegro LED drivers [27], and the

NKK pushbuttons [30]. The layout of the side PCB is important because it interfaces with the

external enclosure of the RoboRubik. There is a pushbutton in the center of each board that sits

in a cutout in the enclosure and the eight LEDs of each board needs to be in the correct location


-23-

to represent the square blocks of a normal Rubik’s Cube. Since all of our components are small

and simple, we do not have to worry about too much current going through our traces. There are

no analog signals to work with either in our project. The WiPort is the only thing that has analog

and RF signals, but that is all self-contained in its own package. The only challenge the WiPort

gave us was the footprint. It is a little difficult to work with because it is in a metal enclosure

and the 40 pins are located on the bottom. The Integration Guide was very helpful.

9.2 PCB Layout Design Considerations – Microcontroller

The microcontroller used is the MC9S12C128 [28] in the 48 pin package. This package is just

like the one from the ECE362 demo kit. Since this microcontroller is so common, it was easy to

determine the layout for it. The documentation was also very helpful. It uses a basic oscillator

circuit with 2 capacitors and a resistor. This circuit was kept as close as possible to the

microcontroller. The other circuit needed was the power supply bypass capacitor circuit. This is

located under the microcontroller on the opposite side of the PCB to keep it close to the clock

pins. There are 6 bypass capacitors used ranging from 0.1 uF to 470 nF. These were the only

major considerations for the microcontroller.

9.3 PCB Layout Design Considerations – WiPort

The WiPort also needs bypass capacitors like the microcontroller. It needs six of them ranging

from 4.7uF to 0.01uF. These need to be right under the power supply pads. The WiPort also

requires a special male header to fit the female header on the underside of the device. This is

important because it needs to be in the exact location for the WiPort to sit correctly on the PCB.

The documentation was very helpful for this and the development board that came with the

WiPort was also a good reference.

9.4 PCB Layout Design Considerations - Power Supply

The power supply circuit is very simple. Since the cube is powered with a battery of 6V to 9V, it

only needed to be stepped down. This is done with aFairchild LDO [23] voltage regulator to

drop the voltage down to 3.3V, the voltage all of the components run on. This circuit is located

in the corner of the main PCB and does not require too large of traces.


-24-

9.5 Summary

Overall the PCBs are very straight forward. The main consideration was keeping them as small

as possible. The PCBs are unique because there are seven of them. There are six for the sides

and a main one in the middle. The side layout is important because it interfaces to the user

through a pushbutton and LEDs. The main board is also important because it contains the main

components and is what will most likely limit the size of our cube.

10 Software Design Considerations The overall software design focuses on the ability of the microcontroller to receive the initial

cube configuration or “state” from the user interface, output this cube state to the LEDs,

determine the steps leading to a solved cube state, and change the cube configuration based on

pushbutton presses subject to the mode of operation. The details of the software considerations

and the software design flow are discussed in the remainder of this section.

10.1 Software Design Considerations

The software design of the RoboRubik project begins with the user interface. The graphical user

interface, GUI, used for the user to input the configuration of the unsolved cube is stored on

RoboRubik’s embedded wireless network device and is accessed via an external computer. The

initial configuration of the cube is transmitted wirelessly from the external computer to

RoboRubik via an internal Lantronix WiPort wireless network device [25]. Once the cube

configuration is received by the microcontroller from the user interface, the configuration is

output to the LEDs and the stored solving algorithm calculates the moves required to reach the

solved cube state. The microcontroller then waits for a pushbutton press to change the state of

the cube depending on the mode of operation. In the Help mode, the microcontroller will walk

through the determined solution in a step-by-step fashion upon a pushbutton press. In the Play

mode, the cube configuration will be changed by the microcontroller based on individual

pushbutton presses. A single press represents a 90° clock-wise “rotation” of the cube face

corresponding to the pushbutton located on that face. It is important to note the cube does not

physically rotate. Instead the LED configuration changes to visually represent a face rotation.


-25-

The overall organization of application code represents a hybrid of both program-driven and

interrupt-driven modes. While RoboRubik is waiting for the initial cube state from the user

interface, the application code utilizes a polled program-driven organization style. The

microcontroller waits for the data from the user interface by constantly polling the wireless

network device. Once the data is received, the solution determined, and the cube configuration

output to the LEDs, the microcontroller enters the interrupt-driven mode. Until a signal to

change the cube state is sent to the microcontroller via a pushbutton, the present configuration is

sent to the LEDs. The pushbutton press fires an interrupt causing the cube state to change to

either the next step in the solution or by “rotating” a face of the cube in the Help or Play mode,

respectively.

It was decided to implement the command-driven or hybrid application code organization since

it was preferred to use both the program-driven and interrupt-driven code organization styles.

The polling program-driven application code organization was chosen while the cube is waiting

for the initial configuration from the user interface since the wireless network device is the only

device being polled requiring a small polling loop and small latency. The interrupt-driven

organization style was selected to be used during the process of changing the cube configuration

since the microcontroller will be constantly sending the configuration status to the LEDs at the

moment a pushbutton is pressed. This requires the microcontroller to interrupt the current LED

output configuration and change the state of the LEDs based on the mode of operation. The SCI,

Serial Communications Interface, peripheral of the microcontroller is used to communicate

between the microcontroller and the wireless network device. The PWM, Pulse-Width

Modulation, peripheral is used to strobe the LEDs and display the configuration of the cube. The

TIM, Timer, module of the microcontroller samples the pushbuttons and fires and interrupt when

a button press is sensed.

There are three main data blocks stored in the microcontroller memory. The first of which is a

lookup table for the LEDs representing a transition diagram. Secondly, the solving algorithm

will be saved in memory. Also, the list steps produced by the solving algorithm will be saved.

The explicit memory locations of this data have yet to be determined mainly due to the lack of a

finalized solving algorithm. Since the microcontroller selected for RoboRubik has 128KB Flash


-26-

and 4KB RAM, it has been determined the amount of memory is sufficient for the application at

hand [28].

10.2 Software Design Narrative

There are four major blocks in the hierarchical arrangement of the RoboRubik code modules;

user interface, main program, configuration output, and pushbutton interrupt. This hierarchical

arrangement is depicted in Figure 10-1 below. The user interface communicates with the cube

via RoboRubik’s internal wireless network device as mentioned above. The wireless network

device connects to the microcontroller serially through the microcontroller’s SCI interface

module [28]. The main program stored on the microcontroller sits in a polling state until

receiving the initial configuration data from the user interface at which point it switches to an

interrupt-driven mode of operation. In this interrupt-driven mode, the configuration output

displays the cube state via LEDs using the PWM module of the microcontroller [28]. While the

cube state is displayed, the main program is interrupted at the press of a pushbutton causing the

state of the cube to be changed according to the mode of operation and the specific pushbutton

pressed.

Figure 10-1: Hierarchical Block Diagram


-27-

10.3 Summary

The software design of RoboRubik consists of the above mentioned considerations and narrative.

The two main organization aspects of the software design correspond to the receiving of the

initial cube state and the altering of the current state. While receiving the initial state, the main

program runs in a program-driven fashion. The main program operates as an interrupt-driven

organization mode during the changing of the current state. A listing of the code used for

RoboRubik is included in Appendix F.

11 Version 2 Changes Now that RoboRubik is complete there a few changes that would have made to its design. First

the overall package would have been constructed smaller. RoboRubik is currently about the same

size as the Rubik Revolution and it would have been nice to keep it close to the same size as the

original Rubik’s Cube. Also, headers for the microcontroller were placed on the PCB design and

were never used during the testing or implementation of RoboRubik. These headers would have

been removed, thus making the PCB layout smaller and easier to create. The LDO would also

have been moved to a different location so the user doesn’t burn their finger trying to turn on

RoboRubik.

The WiPort, while a very powerful and useful component, is the largest part of the design. Next

time a smaller and more compact device would be used. The WiPort was not used entirely in the

design of RoboRubik and a smaller device could have still provided the same functionality used.

One more change would be to use a pushbutton with an embedded LED for each of the center

squares. While the pushbuttons used are effective and do the job well, not having nine LEDs of

the same color is not a perfect aesthetic choice.

If the RoboRubik model was to be mass produced as a consumer toy, the final packaging of the

cube should be permanent without access to the internal circuitry. The location of the on/off

switch could be moved to the exterior of the cube to make access by the user easier and less

invasive. Another design alteration might be the implementation of a rechargeable battery.

Without access to the cube’s interior, this would require charging by induction. Thus, a charging

unit with AC/DC wall adapter would be included with RoboRubik for charging the battery.


-28-

12 Summary and Conclusions Through the completion of RoboRubik we learned a great deal. No one on the team had done

much hardware design before aside from the work done in ECE 270 and ECE 362. This project

really challenged us to go above and beyond our current skill set and acquire new knowledge.

Most of us had never soldered before starting this project. We also learned a great deal about

how components from different manufacturers can be combined to create a working circuit as

well as how to create a printed circuit board layout using OrCAD.

We also learned a lot about wireless networking and serial communications. Our packaging

design was a good challenge because we had to take into account many factors in its design. We

learned much about the Rubik’s Cube itself and how its design influences its challenge and

difficulty. Lastly, we had our ability to work as team put to the test and all four of us worked

very well together.

13 References [1] “16-bit Microcontrollers MC9S12C32,” [Online document], [cited 2008 Jan 29], Available

HTTP: http://www.freescale.com/files/microcontrollers/doc/fact_sheet/MC9S12C32FS.pdf [2] “RECOM Power Inc. – Our DC/DC Highseller,” [Online document], [cited 2008 Jan 29],

Available HTTP: http://www.recom-power.com/pages/highseller.php [3] “Allegro | Product | A6276 16-Bit Serial-Input, Constant Current Latched LED Driver,”

[Online document], [cited 2008 Jan 29], Available HTTP: http://www.allegromicro.com/en/Products/Part_Numbers/6276/

[4] “TT Electronics plc,” [Online document], [cited 2008 Jan 29], Available HTTP:

http://www.optekinc.com/products/VLED_smd.asp [5] “WiPort – Embedded 802.11, Embedded Ethernet, 802.11g,” [Online document], [cited

2008 Jan 29], Available HTTP: http://www.lantronix.com/device-networking/embedded-device-servers/wiport.html

[6] “Rubik’s Official Online Site,” [Online document], [cited 2008 Jan 29], Available HTTP:

http://www.rubiks.com/ [7] “WiPort vs. MatchPort B/G Compared,” [Online document], [cited 2008 Jan 29], Available

HTTP:


-29-

http://www.gridconnect.com/wpvsmp.html [8] “MC9S12C128 Product Summary Page,” [Online document], [cited 2008 Jan 29],

Available HTTP: http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=MC9S12H256&fsrch=1

[9] United States Patent and Trademark Office Patent #6,974,130, [Online document], 2005 Dec,

[cited 2008 Mar 27], Available HTTP: http://patft.uspto.gov/netacgi/nph-Parser?Sect1=PTO2&Sect2=HITOFF&p=1&u=%2Fnetahtml%2FPTO%2Fsearch-bool.html&r=15&f=G&l=50&co1=AND&d=PTXT&s1=rubik&OS=rubik&RS=rubik

[10] United States Patent and Trademark Office Patent #5,310,183, [Online document], 1994 May, [cited 2008 Mar 27], Available HTTP: http://patft.uspto.gov/netacgi/nph-Parser?Sect1=PTO2&Sect2=HITOFF&p=2&u=%2Fnetahtml%2FPTO%2Fsearch-bool.html&r=91&f=G&l=50&co1=AND&d=PTXT&s1=rubik&OS=rubik&RS=rubik

[11] United States Patent and Trademark Office Patent #5,651,715, [Online document], 1997 July,

[cited 2008 Mar 27], Available HTTP: http://patft.uspto.gov/netacgi/nph-Parser?Sect1=PTO1&Sect2=HITOFF&d=PALL&p=1&u=%2Fnetahtml%2FPTO%2Fsrchnum.htm&r=1&f=G&l=50&s1=5,651,715.PN.&OS=PN/5,651,715&RS=PN/5,651,715

[12] MIL-HDBK-217F, United States Department of Defense, 2 January 1990. [13] “Optek OVSRRGBCC3 Datasheet” [Online document], [cited 2008 Apr 28] Available

HTTP: http://www.optekinc.com/pdf/OVSRRGBCC3.pdf

[14] Martin Tarr, "PCB recycling issues", [Online Document] [cited 2008 Apr 28] Available HTTP: http://www.ami.ac.uk/courses/topics/0113_prei/index.html

[15] “Waste Minimization Assessment for a Printed Circuit Board Manufacturer,” Looby and

Kirsch. [Online Document], [cited 2008 Apr 28] Available HTTP: http://www.p2pays.org/ref/02/01084.pdf.

[16] Wikipedia, "Restriction of Hazardous Substances Directive", [Online Document] [cited

2008 Apr 28] Available HTTP: http://en.wikipedia.org/wiki/Restriction_of_Hazardous_Substances_Directive

[17] “ICER: Industry Council for Electronic Equipment Recycling”, [Online Document] [cited

2008 Apr 28] Available HTTP: http://www.icer.org.uk/index.htm

[18] “Eastern Environmental”, [Online Document] [cited 2008 Apr 28] Available HTTP: http://www.easternenvironmental.com/


-30-

[19] “Rubik’s Official Online Site,” [Online document], [cited 2008 Feb 08], Available HTTP:

http://www.rubiks.com

[20] “Rubik’s Revolution Official Online Site,” [Online document], [cited 2008 Feb 08], Available HTTP: http://www.rubiksrevolution.com/

[21] “Plexiglas Optical and Transmission Characteristics,” [Online document], [cited 2008 Feb

08], Available HTTP: http://www.plexiglas.com/literature/pdf/81.pdf [22] “Energizer 6V EL2CR5 Lithium” [Online document], [cited 2008 Apr 28] Available

HTTP: http://data.energizer.com/PDFs/2cr5.pdf [23] “Fairchild KA378R33 Datasheet” [Online document], [cited 2008 Apr 28] Available

HTTP: http://www.fairchildsemi.com/ds/KA/KA378R33.pdf [24] “MC9S12C Family User Guide” [Online document], [cited 2008 Apr 28], Available

HTTP: http://www.freescale.com/files/microcontrollers/doc/data_sheet/MC9S12C128V1.pdf

[25] “Lantronix WiPort Datasheet” [Online document], [cited 2008 Apr 28], Available

HTTP: http://www.lantronix.com/pdf/WiPort_DS.pdf [26] “Lantronix WiPort User Guide” [Online document], [cited 2008 Apr 28] Available

HTTP: http://www.lantronix.com/pdf/WiPort_UG.pdf [27] “Allegro A6279 Datasheet” [Online document], [cited 2008 Apr 28] Available

HTTP: http://www.allegromicro.com/en/Products/Part_Numbers/6278/6278.pdf

[28] “MC9S12C Family User Guide” [Online document], [cited 2008 Feb 22], Available HTTP: http://cobweb.ecn.purdue.edu/~477grp11/files/datasheets/Microcontroller%20MC9S12C128%20-%20Freescale.pdf

[29] “Lantronix WiPort Integration Guide” [Online document], [cited 2008 Feb 22], Available

HTTP: http://www.lantronix.com/pdf/WiPort_IG.pdf

[30] “NKK Series CB3 Pushbutton Datasheet“[Online document], [cited 2008 Feb 22] Available HTTP: www.nkkswitches.com/pdf/CB3.pdf


A-1

Appendix A: Individual Contributions A.1 Contributions of Erik Carron:

My main contributions towards the completion of RoboRubik were the printed circuit board

layout narrative, the reliability and safety analysis, and the design of the printed circuit board

(PCB) layout. I also was the one who came up with the idea of creating a digitalized Rubik’s

Cube. Most of my background is in software, which I enjoy, but I decided to do something

different and worked mostly with the hardware design of the RoboRubik.

When we first began the planning of the RoboRubik, our initial thought was to have it

mechanically rotate. I took on the role of testing stepper motors to see how we could do this in

such a small package. I determined that this was not going to be possible with our experience and

tools so I came up with the idea of changing it to a static cube with LEDs to represent the colors

of the blocks. Once we started to design the new RoboRubik, I decided that my contributions

would be mainly focused on the PCB layout design and hardware selection. I worked with my

teammates in selecting the components and I was able to find our wireless device, the WiPort. I

did some research on it and used my networking experience to determine that it was the perfect

device to use. After all of our components were selected, I started my training with Cadence

Layout Plus.

Since this was my first time working with PCB layout, it took me some time to figure it out. I

worked with Dave to get the schematic corrected and completed so I could start our layout. I

spend countless days and nights working on this. I was jumping from device data sheets, to the

schematic, to the layout program. I had to make sure that it was flawless so that we would not

run into any problems down the road. Dave and Tyler helped me out a lot when it came down to

the deadline.

Once we had the PCBs out for fabrication, I went on to testing some of our components that

came in. I first did testing on the very small LEDs with the help of Chuck. I then went on to test

the LED drivers by programming the ECE 362 development board to clock and shift data in.


A-2

Dave assisted me in doing this and we were able to get everything figured out so when we got

the PCBs back we could get started right away.

Once we got the PCBs, I did a lot of the populating. I got one of the sides fully populated and

programmed the ECE 362 development board again to clock and shift data in to test it. We ran

into several problems at first, which Dave and I worked on and eventually solved. Once we got

one side fully working, I populated the rest of the side PCBs with Tyler. I then focused on

getting the main board working. I populated it with the help of Tyler again and did the first

testing of the microcontroller. It took me a while to figure everything out but I was able to

program the microcontroller with the background debug mode (BDM). I then set up all the

initializations in the assembly code for the microcontroller and passed it on to Casey so he could

start his programming.

While Dave and Casey worked with each other on the software, Tyler and I worked on the

external Plexiglas packaging. He got the rough cutouts of the Plexiglas and we then worked

together to come up with ideas to bring everything together. We decided to sand down the edges

and use clear silicon sealant to hold it all together. We also painted the pushbuttons different

colors to help the user.

A.2 Contributions of Dave Bukiet: As a computer engineer with an interest and knowledge of signal processing, my main

contributions to RoboRubik were the hardware design narrative, the communication protocol

between the WiPort and microcontroller and the Java user interface. My understanding of signal

processing made me the best candidate to work on the communication between the

microcontroller and WiPort. My experience with Java as well as my knowledge of networking

gave me useful skills in working with the WiPort.

During the planning stages of RoboRubik I worked with my teammates to finalize ideas about

how we would design the circuitry of the project. It was recommended that we use some sort of

driver to power our LEDs and I did a lot of research on how this system would work. I did a lot

of component research and picked out the LEDs we ultimately ended up using. I did some testing


A-3

with the LED drivers we chose to determine if they would be suitable for our design. Once we

had all of our components chosen I worked on the hardware design narrative.

After familiarizing myself with the specifics of each component, the design of the schematic was

my responsibility. I spent a lot of time making sure that all components chosen could operate

correctly and be combined to form a working circuit. Once the schematic was finalized I also

worked with Erik on the layout of the PCB design.

Once we had sent the PCB design off for fabrication, I started working with the WiPort and

determining what the best configuration was. I spent a lot of time testing simple communication

programs between the WiPort and our ECE 362 development board. This would ensure that once

our main circuit board was populated it would be easy to implement communication between the

WiPort and microcontroller.

Once we received our PCBs back from fabrication I helped my team test a fully populated side

board. This board contained two LED drivers and eight LEDs. After a number of hurdles we

finally got the circuit working correctly and began populating the rest. I also worked heavily to

design the overall structure of the user interface as well as how the code on the microcontroller

should integrate with it.

After some debate we found that using the microcontroller to solve the cube would be a greater

challenge than expected and we decided to use an available Java applet to do the solving. This

applet was embedded on the WiPort and could be easily connected to using a wireless

connection. Once Casey had found the open-source applet and modified some of the code, I

heavily modified the code to include our communication system as well as other functionality. I

worked with Casey near the end of development to make sure that his microcontroller code and

my Java applet would sync up correctly.

A.3 Contributions of Tyler Heck: The main contributions I made to the RoboRubik project included, but were not limited to, the

design constraint analysis report; software design considerations, narrative, and documentation;


A-4

and packaging construction. As a computer engineer, my knowledge of software design allowed

me to properly develop the software which would eventually run RoboRubik. Having taken a

few courses in civil engineering, my experience in structural analysis along with my background

in general craftsmanship made me the best person for designing and constructing the internal and

exterior packaging of RoboRubik.

I was solely responsible for the designing of the RoboRubik website. Throughout the course of

the semester, it was my duty to update the group website with current information on design

changes and post documents as they were completed. With assistance from my teammates, my

first assignment was to draft a design constraint report based on the components we selected for

the RoboRubik project. This component selection served as the foundation of later design

considerations.

Although it was not part of my individual assignment, I spent a great deal of time on the PCB

layout of our project. I spent a over fifteen hours working in the main PCB and side PCB layout

in order to complete the assignment and send the PCB layout for fabrication on time.

Throughout the project, Erik and I were the two group members responsible for soldering. This

included soldering components onto the PCBs, creating connectors for the batteries and side

PCBs, de-soldering, and often re-soldering. Once the PCBs were back from fabrication, I

soldered approximately 60% of all components on the main PCB and 85% of all side PCB

components. When the project was near completion, I connected four of the side PCBs to the

main PCB via right-angle headers and the remained two side PCBs by connectors mentioned

above.

At the beginning of the semester, I was intended to implement the Rubik’s Cube solving

algorithm and assist Dave in the software communications interfacing. We were able to find

some open-source code for a Rubik’s Cube solving algorithm which could be stored on our

wireless network device. Thus, my initial role was outsourced. I spent some time with Dave

designing the communications protocol between the microcontroller and wireless network device

with Dave making the majority of the contribution in this area. At the point in the semester


A-5

when our PCBs were not fully populated and software testing could not proceed, I took the

initiative to pursue the fabrication of RoboRubik’s external housing. At this point, Casey and I

switched roles as he would produce the microcontroller software and I would develop the

packaging.

My major contribution toward the end of the project was the final packaging design. One

packaging contribution included the idea of placing magnets cut into right-angle triangles in the

four corners inside the internal PCB structure to add stability and allow for the removal of the

top face. I was exclusively in charge of constructing the plexiglass pieces later used to create an

exterior shell to house RoboRubik. I went to the EE machine shop and assisted Chuck

Harrington in the initial cutting of the plexiglass and button caps. I later made frequent trips to

the shop to sand and bevel the pieces to properly fit the internal PCB structure. Once the internal

PCB structure of RoboRubik was finished and the software development was nearing

completion, Erik and I attached the plexiglass pieces together allowing the internal structure to

slide in perfectly. Once the packaging was finished, the team recorded and edited the

RoboRubik video; I created the project poster; and the RoboRubik project was complete.

A.4 Contributions of Casey Kloiber: My main contributions toward the completion of RoboRubik were the packaging design

narrative, the patent liability issues report, and the development of the microcontroller software.

My background in programming in several different languages throughout my time in college

and even beforehand in high school made me the ideal person for the software development for

the microcontroller. I also aided in the development of the Java user interface applet.

When we first decided that our project was going to be RoboRubik, I decided that my

contribution would be mainly geared towards the packaging and I would assist in the software

development of the microcontroller. In the beginning when there wasn’t much packaging to be

done, I assisted my teammates in deciding on appropriate parts to obtain for appropriate

functionality of our cube. One of the two LED drivers I had researched ultimately became the

part we used to interface with our forty-eight tri-color LEDs. After the parts had been finalized,

I familiarized myself with various programs that had the ability to solve the Rubik’s Cube.


A-6

Since my teammates were focusing on hardware so that the PCB design would be finished in

time for fabrication, I devoted all of my time into finding a piece of software that would be

optimal in not only interfacing with the users of RoboRubik, but also would provide a simple and

straightforward interface to our microcontroller. After testing several programs that were

developed in C++, an applet that was programmed in Java became our new target for

development.

I altered the user interface of the Java applet to suit our needs and changed some of the

functionality so that extraneous user input wouldn’t alter the state of the cube and cause

problems. After I had completed the aesthetics of the applet, Dave took over with the rest of the

development of the communication software that our Java applet would need. Around this time

the PCB had come back from fabrication and population was under way so I aided in the testing

and debugging of several of the parts.

After the board was fully populated was when I began writing the software for the

microcontroller. Tyler was originally listed as the lead in software development, but we traded

roles and as he worked tirelessly on getting the packaging for the cube prepared, I worked on the

software for the microcontroller that would display the appropriate colors on the correct sides.

After completing the main segment of code for the microcontroller, Dave and I worked on

communication between the WiPort and microcontroller. When all the pushbuttons and lights

worked on the cube, the final bit of functionality we got working was updating RoboRubik from

commands sent from the WiPort. After that, we all created our poster and video and the project

was complete.


B-1

Appendix B: Packaging

Figure B-1: Cut-Away Internal View


B-2

Figure B-2: Exploded Individual Side View


C-1

Appendix C: Schematic

Figure C-1: Schematic for Main PCB


C-2

Figure C-2: Schematic for Side PCBs


D-1

Appendix D: PCB Layout Top and Bottom Copper .

Figure D-1: PCB Layout for Main PCB


D-2

Figure D-2: PCB Layout for Side PCBs


E-1

Appendix E: Parts List Spreadsheet

Table E-1: Parts List

Vendor Manufacturer Part No. Description Digi-Key Freescale MC9S12C128 16-Bit Microcontroller Gridconnect Lantronix WiPort Wireless Networking Device Digi-Key Abracon Corp ASV Oscillator Digi-Key Fairchild KA378R33 LDO Allegro MicroSystems Allegro MicroSystems A6279 16-Bit LED Driver Digi-Key TT Electronics OVSRRGBCC3 RGB Surface Mount LED Digi-Key Texas Instruments CD74HC4067 1:16 MUX/DEMUX Wal-Mart Energizer EL2CR5 6V battery


F-1

Appendix F: Software Listing ;*********************************************************************** ; RoboRubik 1.0 ;*********************************************************************** ; ;This code controls everything about the microcontroller in our ;RoboRubik project. It's main use is to take the values stored ;in the LED driver registers and paint the faces of the cube ;accordingly. It also interfaces with the Wiiport via SCI by either ;sending values to update the java applet or receiving values from the ;applet to update the LED registers on our cube and repaint the sides ;accordingly. ; ; ====================================================================== ; ; Variable declarations (SRAM) ; ; *** NOTE *** Others can be added if deemed necessary ; org $3800 pbA rmb 1 ; side A pushbutton flag pbB rmb 1 ; side B pushbutton flag pbC rmb 1 ; side C pushbutton flag pbD rmb 1 ; side D pushbutton flag pbE rmb 1 ; side E pushbutton flag pbF rmb 1 ; side F pushbutton flag prevpb rmb 1 ; previous pushbutton state paint rmb 1 setled rmb 1 storeinfo rmb 1 countclk rmb 1 countled rmb 1 countlights rmb 1 countdrivers rmb 1 fixglitch1 rmb 1 fixglitch2 rmb 1 fixglitch3 rmb 1 fixglitch4 rmb 1 fixglitch5 rmb 1 fixglitch6 rmb 1 temp rmb 2 regholder1 rmb 2 regholder2 rmb 2 regholder3 rmb 2 regholder4 rmb 2 onecnt rmb 1 ; counter for 1 ms halfsec rmb 1 ; flag for half a second WHITE rmb 1 MAGENTA rmb 1 YELLOW rmb 1 RED rmb 1 BLUE rmb 1 GREEN rmb 1 counter1 rmb 1 counter2 rmb 1 frontled1 rmb 2 frontled2 rmb 2 backled1 rmb 2 backled2 rmb 2 topled1 rmb 2


F-2

topled2 rmb 2 bottomled1 rmb 2 bottomled2 rmb 2 leftled1 rmb 2 leftled2 rmb 2 rightled1 rmb 2 rightled2 rmb 2 ;*********************************************************************** ; ; ASCII character definitions ; RET equ $0d ; return NULL equ $00 ; NULL LF equ $0A ; Line Feed ;======================================================================== ; ; 9S12C32 REGISTER MAP INITRM EQU $0010 ; INITRM - INTERNAL RAM POSITION REGISTER INITRG EQU $0011 ; INITRG - INTERNAL REGISTER POSITION REGISTER ; ==== CRG - Clock and Reset Generator SYNR EQU $0034 ; CRG synthesizer register REFDV EQU $0035 ; CRG reference divider register CRGFLG EQU $0037 ; CRG flags register CRGINT EQU $0038 CLKSEL EQU $0039 ; CRG clock select register PLLCTL EQU $003A ; CRG PLL control register RTICTL EQU $003B COPCTL EQU $003C ; ==== SCI Register Definitions SCIBDH EQU $00C8 ; SCI0BDH - SCI BAUD RATE CONTROL REGISTER SCIBDL EQU $00C9 ; SCI0BDL - SCI BAUD RATE CONTROL REGISTER SCICR1 EQU $00CA ; SCI0CR1 - SCI CONTROL REGISTER SCICR2 EQU $00CB ; SCI0CR2 - SCI CONTROL REGISTER SCISR1 EQU $00CC ; SCI0SR1 - SCI STATUS REGISTER SCISR2 EQU $00CD ; SCI0SR2 - SCI STATUS REGISTER SCIDRH EQU $00CE ; SCI0DRH - SCI DATA REGISTER SCIDRL EQU $00CF ; SCI0DRL - SCI DATA REGISTER PORTB EQU $0001 ; PORTB - DATA REGISTER DDRB EQU $0003 ; PORTB - DATA DIRECTION REGISTER ; ==== ATD (analog to Digital) Converter / Pushbutton Digital Inputs ATDCTL2 EQU $0082 ; ATDCTL2 control register ATDCTL3 EQU $0083 ; ATDCTL3 control register ATDCTL4 EQU $0084 ; ATDCTL4 control register ATDCTL5 EQU $0085 ; ATDCTL5 control register ATDSTAT EQU $0086 ; ATDSTAT0 status register ATDDIEN EQU $008D ; Port AD digital input enable ; (programs Port AD bit positions as digital inputs) PTADI EQU $008F ; Port AD data input register ; (for reading digital input bits) ATDDR0 EQU $0090 ; result register array (16-bit values) ATDDR1 EQU $0092


F-3

ATDDR2 EQU $0094 ATDDR3 EQU $0096 ATDDR4 EQU $0098 ATDDR5 EQU $009A ATDDR6 EQU $009C ATDDR7 EQU $009E ; ==== Direct Port Pin Access/Control - Port T PTT EQU $0240 ; Port T data register PTIT EQU $0241 ; Port T input read register DDRT EQU $0242 ; Port T data direction register ; ==== Direct Port Pin Access/Control - Port AD PTAD EQU $0270 ; Port AD data register PTIAD EQU $0271 ; Port AD input read register DDRAD EQU $0272 ; Port AD data direction register ; ==== TIM - Timer 16 Bit 8 Channels TIOS EQU $0040 ;TIOS - TIMER INPUT CAPTURE/OUTPUT COMPARE SELECT CFORC EQU $0041 ;CFORC - TIMER COMPARE FORCE REGISTER OC7M EQU $0042 ;OC7M - OUTPUT COMPARE 7 MASK REGISTER OC7D EQU $0043 ;OC7D - OUTPUT COMPARE 7 DATA REGISTER TCNT EQU $0044 TCNTH EQU $0044 TCNTL EQU $0045 TSCR1 EQU $0046 ;TSCR - TIMER SYSTEM CONTROL REGISTER TTOV EQU $0047 TCTL1 EQU $0048 ;TCTL1 - TIMER CONTROL REGISTER 1 TCTL2 EQU $0049 ;TCTL2 - TIMER CONTROL REGISTER 3 TCTL3 EQU $004A ;TCTL3 - TIMER CONTROL REGISTER 3 TCTL4 EQU $004B ;TCTL4 - TIMER CONTROL REGISTER 3 TIE EQU $004C TSCR2 EQU $004D TFLG1 EQU $004E ;TFLG1 - TIMER INTERRUPT FLAG 1 TFLG2 EQU $004F ;TFLG2 - TIMER INTERRUPT FLAG2 TC0 EQU $0050 ;TC0 - TIMER INPUT/CAPTURE COMPARE HIGH REGISTER TC1 EQU $0052 ;TC1 - TIMER INPUT/CAPTURE COMPARE HIGH REGISTER TC2 EQU $0054 ;TC2 - TIMER INPUT/CAPTURE COMPARE HIGH REGISTER TC3 EQU $0056 ;TC3 - TIMER INPUT/CAPTURE COMPARE HIGH REGISTER TC4 EQU $0058 ;TC4 - TIMER INPUT/CAPTURE COMPARE HIGH REGISTER TC5 EQU $005A ;TC5 - TIMER INPUT/CAPTURE COMPARE HIGH REGISTER TC6 EQU $005C ;TC6 - TIMER INPUT/CAPTURE COMPARE HIGH REGISTER TC7 EQU $005E ;TC7 - TIMER INPUT/CAPTURE COMPARE HIGH REGISTER ; ==== IMPORTANT -- Routing register for Port T (selects TIM vs PWM mapping) MODRR EQU $0247 ; Port T module routing register ; NOTE: Used to select TIM or PWM mapping to Port T pins ; ==== PA - Pulse Accumulator PACTL EQU $0060 ;PATCL - PULSE ACCUMULATOR CONTROL REGISTER PAFLG EQU $0061 ;PAFLG - PULSE ACCUMULATOR FLAG REGISTER PACNT EQU $0062 ;PACNT - PULSE ACCUMULATOR COUNT REGISTER ; ==== PWM - Pulse width Modulator


F-4

PWME EQU $00E0 ; PWM enable PWMPOL EQU $0000 ; PWM polarity PWMCLK EQU $00E2 ; PWM clock source select PWMPRCLK EQU $00E3 ; PWM pre-scale clock select PWMCAE EQU $00E4 ; PWM center align enable PWMCTL EQU $0000 ; PWM control (concatenate enable) PWMSCLA EQU $00E8 ; PWM clock A scaler PWMSCLB EQU $00E9 ; PWM clock B scaler PWMPER0 EQU $00F2 ; PWM period registers PWMPER1 EQU $00F3 PWMPER2 EQU $00F4 PWMPER3 EQU $00F5 PWMPER4 EQU $00F6 PWMPER5 EQU $00F7 PWMDTY0 EQU $00F8 ; PWM duty registers PWMDTY1 EQU $00F9 PWMDTY2 EQU $00FA PWMDTY3 EQU $00FB PWMDTY4 EQU $00FC PWMDTY5 EQU $00FD ; ====================================================================== REGBASE EQU $0 ; registers start at 0000 RAMBASE EQU $3800 ; 4KB SRAM located at 3000-3FFF ;*********************************************************************** ; BOOT-UP ENTRY POINT ;*********************************************************************** org $8000 startup sei ; Disable interrupts movb #$00,INITRG ; set registers to $0000 movb #$39,INITRM ; map RAM ($3800 - $3FFF) lds #$3FCE ; initialize stack pointer ; ; Set the PLL speed (bus clock = 24 MHz) ; bclr CLKSEL,$80 ; disengage PLL from system bset PLLCTL,$40 ; turn on PLL movb #$2,SYNR ; set PLL multiplier movb #$0,REFDV ; set PLL divider nop nop plp brclr CRGFLG,$08,plp ; while (!(crg.crgflg.bit.lock==1)) bset CLKSEL,$80 ; engage PLL ; ; Disable watchdog timer (COPCTL register) ; movb #$40,COPCTL ; COP off; RTI and COP stopped in BDM-mode ; ; Initialize asynchronous serial port (SCI) for 9600 baud, no interrupts ; movb #$00,SCIBDH ; set baud rate to 9600 movb #$9C,SCIBDL ; 24,000,000 / 16 / 156 = 9600 (approx)


F-5

movb #$00,SCICR1 ; $9C = 156 movb #$0C,SCICR2 ; initialize SCI for program-driven operation movb #$10,DDRB ; set PB4 for output mode movb #$10,PORTB ; assert DTR pin on COM port txdre equ $80 rxdrf equ $20 ;*********************************************************************** ; START OF CODE FOR EXPERIMENT ;*********************************************************************** ; ; Flag and variable initializations ; ; *** NOTE *** Add any others deemed necessary ; movb pbA,$00 movb pbB,$00 movb pbC,$00 movb pbD,$00 movb pbE,$00 movb pbF,$00 clr prevpb clr onecnt clr halfsec clr countclk clr countled clr countlights clr countdrivers clr paint clr regholder1 clr regholder2 clr setled clr fixglitch1 clr fixglitch2 clr fixglitch3 clr fixglitch4 clr fixglitch5 clr fixglitch6 clr storeinfo movw #$0000, frontled1 movw #$0000, frontled2 movw #$0000, backled1 movw #$0000, backled2 movw #$0000, topled1 movw #$0000, topled2 movw #$0000, bottomled1 movw #$0000, bottomled2 movw #$0000, leftled1 movw #$0000, leftled2 movw #$0000, rightled1 movw #$0000, rightled2 movb #$07,WHITE movb #$05,MAGENTA movb #$06,YELLOW movb #$04,RED movb #$01,BLUE movb #$02,GREEN


F-6

ldd frontled1 eorb YELLOW jsr lsld_func eorb YELLOW jsr lsld_func eorb YELLOW jsr lsld_func eorb YELLOW std frontled1 ldd frontled2 eorb YELLOW jsr lsld_func eorb YELLOW jsr lsld_func eorb YELLOW jsr lsld_func eorb YELLOW std frontled2 ldd backled1 eorb WHITE jsr lsld_func eorb WHITE jsr lsld_func eorb WHITE jsr lsld_func eorb WHITE std backled1 ldd backled2 eorb WHITE jsr lsld_func eorb WHITE jsr lsld_func eorb WHITE jsr lsld_func eorb WHITE std backled2 ldd topled1 eorb BLUE jsr lsld_func eorb BLUE jsr lsld_func eorb BLUE jsr lsld_func eorb BLUE std topled1 ldd topled2 eorb BLUE jsr lsld_func eorb BLUE jsr lsld_func eorb BLUE jsr lsld_func eorb BLUE std topled2 ldd bottomled1 eorb GREEN jsr lsld_func eorb GREEN jsr lsld_func eorb GREEN jsr lsld_func eorb GREEN std bottomled1


F-7

ldd bottomled2 eorb GREEN jsr lsld_func eorb GREEN jsr lsld_func eorb GREEN jsr lsld_func eorb GREEN std bottomled2 ldd leftled1 eorb RED jsr lsld_func eorb RED jsr lsld_func eorb RED jsr lsld_func eorb RED std leftled1 ldd leftled2 eorb RED jsr lsld_func eorb RED jsr lsld_func eorb RED jsr lsld_func eorb RED std leftled2 ldd rightled1 eorb MAGENTA jsr lsld_func eorb MAGENTA jsr lsld_func eorb MAGENTA jsr lsld_func eorb MAGENTA std rightled1 ldd rightled2 eorb MAGENTA jsr lsld_func eorb MAGENTA jsr lsld_func eorb MAGENTA jsr lsld_func eorb MAGENTA std rightled2 ; Initialize digital I/O port pins movb #$00,ATDDIEN ; program PAD pins to all output movb #$3F,prevpb ; initialize previous pushbutton state movb #$C0,DDRT ; initialize PT pins movb #$3F,DDRAD ; initialize PTAD pins ; Initialize RTI for 2.048 ms interrupt rate movb #$1F,RTICTL bclr CRGINT,$80 ; ; Initialize the PWM unit to produce a signal with the following ; characteristics on PWM output channel 2: ; - sampling frequency of approximately 100 Hz ; - left-aligned, negative polarity


F-8

; - period register = $FF (yielding a duty cycle range of 0% to 100%, ; for duty cycle register values of $00 to $FF ; - duty register = $00 (motor initially stopped) ; ; IMPORTANT: Need to set MODRR so that PWM Ch 2 is routed to port pin PT2 ; ; movb #$20,PWME ;enable ch 5 movb #$00,MODRR movb #$04,PWMPRCLK ;clock A = bus clock / 16 movb #!75,PWMSCLA ;clock SA = clock A / (2 * 75) movb #$00,PWMPOL movb #!100,PWMPER5 ;period movb #$00,PWMCAE ;left aligned movb #$20,PWMCLK ;clock = clock SA movb #!50,PWMDTY5 ; duty cycle, 0% to 100% ; output freq = 24Mhz / 16 / PER / (2 * 75) ; Initialize TIM Ch 7 (TC7) for periodic interrupts every 1 ms ; Enable timer subsystem ; Set channel 7 for output compare ; Set appropriate pre-scale factor and enable counter reset after OC7 ; Set up channel 7 to generate 1 ms interrupt rate ; Initially disable TIM Ch 7 interrupts movb #$80,TSCR1 movb #$80,TIOS movb #$0C,TSCR2 movw #!1500,TC7 movb #$00,TIE cli ;================================================================ ; ; Start of main loop ; ; *** NOTE *** Add anything else you deem necessary ; bclr PTT,$C0 bclr PTAD,$3F bset TIE,$80 ;enable timer interrupt bclr PTAD,$20 ;active low enable for MUX bset PTAD,$0C ;select output to none for MUX bset PTAD,$10 ;set MUX input to high bclr PTT,$80 ;set data to low bset PTT,$40 ;set clock to high movb pbA,$00 movb pbB,$00 movb pbC,$00 movb pbD,$00 movb pbE,$00 movb pbF,$00 inc paint main_loop ldaa paint cmpa #$01 lblo mains


F-9

jmp stillpainting mains brclr SCISR1,rxdrf,main1 ldaa SCIDRL jsr incomingData main1 ldaa pbA beq main2 clr pbA jsr pressedRight jmp main2 main2 ldaa pbB beq main3 clr pbB jsr pressedFront jmp main3 main3 ldaa pbC beq main4 clr pbC jsr pressedLeft jmp main4 main4 ldaa pbD beq main5 clr pbD jsr pressedBack jmp main5 main5 ldaa pbE beq main6 clr pbE jsr pressedTop jmp main6 main6 ldaa pbF beq main7 clr pbF jsr pressedBottom jmp main7 main7 ldaa paint cmpa #$01 lblo loop stillpainting jsr painting_solved loop jmp main_loop ; main is a continuous polling loop ;*********************************************************************** ;incomingData incomingData cmpa #$C1 lbne next1 jmp gohome


F-10

next1 cmpa #$C2 lbne next2 jmp gohome next2 cmpa #$C3 lbne next3 jsr setpushbutton jmp gohome next3 cmpa #$40 lbne gohome jsr resetstate gohome rts ;*********************************************************************** ;setpushbutton setpushbutton jsr getData cmpa #$01 bne bt2 jsr pressedFront jmp bt8 bt2 cmpa #$02 bne bt3 jsr pressedBack jmp bt8 bt3 cmpa #$03 bne bt4 jsr pressedTop jmp bt8 bt4 cmpa #$04 bne bt5 jsr pressedBottom jmp bt8 bt5 cmpa #$05 bne bt6 jsr pressedLeft jmp bt8 bt6 cmpa #$06 bne bt7 jsr pressedRight jmp bt8 bt7 jmp bt10 bt8 inc paint clr setled clr countled clr countlights


F-11

clr countdrivers bt9 jsr painting_solved ldaa paint cmpa #$00 bne bt9 jmp setpushbutton bt10 rts ;*********************************************************************** ;registerinfo registerinfo clr countled clr countdrivers clr storeinfo movw #$0000, frontled1 movw #$0000, frontled2 movw #$0000, backled1 movw #$0000, backled2 movw #$0000, topled1 movw #$0000, topled2 movw #$0000, bottomled1 movw #$0000, bottomled2 movw #$0000, leftled1 movw #$0000, leftled2 movw #$0000, rightled1 movw #$0000, rightled2 jsr getData regmain staa storeinfo ldaa countdrivers regd0 cmpa #$00 lbne regd2 ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo r00 cmpa #$41 lbne r01 ldd frontled1 eorb BLUE jsr lsld_func std frontled1 inc countled jsr getData jmp regmain


F-12

r01 cmpa #$42 lbne r02 ldd frontled1 eorb GREEN jsr lsld_func std frontled1 inc countled jsr getData jmp regmain r02 cmpa #$44 lbne r03 ldd frontled1 eorb RED jsr lsld_func std frontled1 inc countled jsr getData jmp regmain r03 cmpa #$45 lbne r04 ldd frontled1 eorb MAGENTA jsr lsld_func std frontled1 inc countled jsr getData jmp regmain r04 cmpa #$46 lbne r05 ldd frontled1 eorb YELLOW jsr lsld_func std frontled1 inc countled jsr getData jmp regmain r05 cmpa #$47 lbne r06 ldd frontled1 eorb WHITE jsr lsld_func


F-13

std frontled1 inc countled jsr getData jmp regmain r06 jmp goaway regd1 inc paint cmpa #$01 lbne regd2 ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo r10 cmpa #$41 lbne r11 ldd frontled2 eorb BLUE jsr lsld_func std frontled2 inc countled jsr getData jmp regmain r11 cmpa #$42 lbne r12 ldd frontled2 eorb GREEN jsr lsld_func std frontled2 inc countled jsr getData jmp regmain r12 cmpa #$44 lbne r13 ldd frontled2 eorb RED jsr lsld_func std frontled2 inc countled jsr getData jmp regmain r13 cmpa #$45 lbne r14 ldd frontled2 eorb MAGENTA


F-14

jsr lsld_func std frontled2 inc countled jsr getData jmp regmain r14 cmpa #$46 lbne r15 ldd frontled2 eorb YELLOW jsr lsld_func std frontled2 inc countled jsr getData jmp regmain r15 cmpa #$47 lbne r16 ldd frontled2 eorb WHITE jsr lsld_func std frontled2 inc countled jsr getData jmp regmain r16 jmp goaway regd2 cmpa #$02 lbne regd3 ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo r20 cmpa #$41 lbne r21 ldd backled1 eorb BLUE jsr lsld_func std backled1 inc countled jsr getData jmp regmain r21 cmpa #$42 lbne r22 ldd backled1 eorb GREEN jsr lsld_func std backled1 inc countled jsr getData jmp regmain r22 cmpa #$44 lbne r23 ldd backled1 eorb RED jsr lsld_func std backled1 inc countled


F-15

jsr getData jmp regmain r23 cmpa #$45 lbne r24 ldd backled1 eorb MAGENTA jsr lsld_func std backled1 inc countled jsr getData jmp regmain r24 cmpa #$46 lbne r25 ldd backled1 eorb YELLOW jsr lsld_func std backled1 inc countled jsr getData jmp regmain r25 cmpa #$47 lbne r26 ldd backled1 eorb WHITE jsr lsld_func std backled1 inc countled jsr getData jmp regmain r26 jmp goaway regd3 cmpa #$03 lbne regd4 ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo r30 cmpa #$41 lbne r31 ldd backled2 eorb BLUE jsr lsld_func std backled2 inc countled jsr getData jmp regmain r31 cmpa #$42 lbne r32 ldd backled2 eorb GREEN jsr lsld_func std backled2 inc countled jsr getData jmp regmain r32


F-16

cmpa #$44 lbne r33 ldd backled2 eorb RED jsr lsld_func std backled2 inc countled jsr getData jmp regmain r33 cmpa #$45 lbne r34 ldd backled2 eorb MAGENTA jsr lsld_func std backled2 inc countled jsr getData jmp regmain r34 cmpa #$46 lbne r35 ldd backled2 eorb YELLOW jsr lsld_func std backled2 inc countled jsr getData jmp regmain r35 cmpa #$47 lbne r36 ldd backled2 eorb WHITE jsr lsld_func std backled2 inc countled jsr getData jmp regmain r36 jmp goaway regd4 cmpa #$04 lbne regd5 ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo r40 cmpa #$41 lbne r41 ldd topled1 eorb BLUE jsr lsld_func std topled1 inc countled jsr getData jmp regmain r41 cmpa #$42 lbne r42 ldd topled1


F-17

eorb GREEN jsr lsld_func std topled1 inc countled jsr getData jmp regmain r42 cmpa #$44 lbne r43 ldd topled1 eorb RED jsr lsld_func std topled1 inc countled jsr getData jmp regmain r43 cmpa #$45 lbne r44 ldd topled1 eorb MAGENTA jsr lsld_func std topled1 inc countled jsr getData jmp regmain r44 cmpa #$46 lbne r45 ldd topled1 eorb YELLOW jsr lsld_func std topled1 inc countled jsr getData jmp regmain r45 cmpa #$47 lbne r46 ldd topled1 eorb WHITE jsr lsld_func std topled1 inc countled jsr getData jmp regmain r46 jmp goaway regd5 cmpa #$05 lbne regd6 ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo r50 cmpa #$41 lbne r51 ldd topled2 eorb BLUE jsr lsld_func std topled2


F-18

inc countled jsr getData jmp regmain r51 cmpa #$42 lbne r52 ldd topled2 eorb GREEN jsr lsld_func std topled2 inc countled jsr getData jmp regmain r52 cmpa #$44 lbne r53 ldd topled2 eorb RED jsr lsld_func std topled2 inc countled jsr getData jmp regmain r53 cmpa #$45 lbne r54 ldd topled2 eorb MAGENTA jsr lsld_func std topled2 inc countled jsr getData jmp regmain r54 cmpa #$46 lbne r55 ldd topled2 eorb YELLOW jsr lsld_func std topled2 inc countled jsr getData jmp regmain r55 cmpa #$47 lbne r56 ldd topled2 eorb WHITE jsr lsld_func std topled2 inc countled jsr getData jmp regmain r56 jmp goaway regd6 cmpa #$06 lbne regd7 ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo


F-19

r60 cmpa #$41 lbne r61 ldd bottomled1 eorb BLUE jsr lsld_func std bottomled1 inc countled jsr getData jmp regmain r61 cmpa #$42 lbne r62 ldd bottomled1 eorb GREEN jsr lsld_func std bottomled1 inc countled jsr getData jmp regmain r62 cmpa #$44 lbne r63 ldd bottomled1 eorb RED jsr lsld_func std bottomled1 inc countled jsr getData jmp regmain r63 cmpa #$45 lbne r64 ldd bottomled1 eorb MAGENTA jsr lsld_func std bottomled1 inc countled jsr getData jmp regmain r64 cmpa #$46 lbne r65 ldd bottomled1 eorb YELLOW jsr lsld_func std bottomled1 inc countled jsr getData jmp regmain r65 cmpa #$47 lbne r66 ldd bottomled1 eorb WHITE jsr lsld_func std bottomled1 inc countled jsr getData jmp regmain r66 jmp goaway regd7


F-20

cmpa #$07 lbne regd8 ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo r70 cmpa #$41 lbne r71 ldd bottomled2 eorb BLUE jsr lsld_func std bottomled2 inc countled jsr getData jmp regmain r71 cmpa #$42 lbne r72 ldd bottomled2 eorb GREEN jsr lsld_func std bottomled2 inc countled jsr getData jmp regmain r72 cmpa #$44 lbne r73 ldd bottomled2 eorb RED jsr lsld_func std bottomled2 inc countled jsr getData jmp regmain r73 cmpa #$45 lbne r74 ldd bottomled2 eorb MAGENTA jsr lsld_func std bottomled2 inc countled jsr getData jmp regmain r74 cmpa #$46 lbne r75 ldd bottomled2 eorb YELLOW jsr lsld_func std bottomled2 inc countled jsr getData jmp regmain r75 cmpa #$47 lbne r76 ldd bottomled2 eorb WHITE jsr lsld_func


F-21

std bottomled2 inc countled jsr getData jmp regmain r76 jmp goaway regd8 cmpa #$08 lbne regd9 ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo r80 cmpa #$41 lbne r81 ldd leftled1 eorb BLUE jsr lsld_func std leftled1 inc countled jsr getData jmp regmain r81 cmpa #$42 lbne r82 ldd leftled1 eorb GREEN jsr lsld_func std leftled1 inc countled jsr getData jmp regmain r82 cmpa #$44 lbne r83 ldd leftled1 eorb RED jsr lsld_func std leftled1 inc countled jsr getData jmp regmain r83 cmpa #$45 lbne r84 ldd leftled1 eorb MAGENTA jsr lsld_func std leftled1 inc countled jsr getData jmp regmain r84 cmpa #$46 lbne r85 ldd leftled1 eorb YELLOW jsr lsld_func std leftled1 inc countled jsr getData


F-22

jmp regmain r85 cmpa #$47 lbne r86 ldd leftled1 eorb WHITE jsr lsld_func std leftled1 inc countled jsr getData jmp regmain r86 jmp goaway regd9 cmpa #$09 lbne regdA ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo r90 cmpa #$41 lbne r91 ldd leftled2 eorb BLUE jsr lsld_func std leftled2 inc countled jsr getData jmp regmain r91 cmpa #$42 lbne r92 ldd leftled2 eorb GREEN jsr lsld_func std leftled2 inc countled jsr getData jmp regmain r92 cmpa #$44 lbne r93 ldd leftled2 eorb RED jsr lsld_func std leftled2 inc countled jsr getData jmp regmain r93 cmpa #$45 lbne r94 ldd leftled2 eorb MAGENTA jsr lsld_func std leftled2 inc countled jsr getData jmp regmain r94 cmpa #$46


F-23

lbne r95 ldd leftled2 eorb YELLOW jsr lsld_func std leftled2 inc countled jsr getData jmp regmain r95 cmpa #$47 lbne r96 ldd leftled2 eorb WHITE jsr lsld_func std leftled2 inc countled jsr getData jmp regmain r96 jmp goaway regdA cmpa #$0A lbne regdB ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo rA0 cmpa #$41 lbne rA1 ldd rightled1 eorb BLUE jsr lsld_func std rightled1 inc countled jsr getData jmp regmain rA1 cmpa #$42 lbne rA2 ldd rightled1 eorb GREEN jsr lsld_func std rightled1 inc countled jsr getData jmp regmain rA2 cmpa #$44 lbne rA3 ldd rightled1 eorb RED jsr lsld_func std rightled1 inc countled jsr getData jmp regmain rA3 cmpa #$45 lbne rA4 ldd rightled1 eorb MAGENTA


F-24

jsr lsld_func std rightled1 inc countled jsr getData jmp regmain rA4 cmpa #$46 lbne rA5 ldd rightled1 eorb YELLOW jsr lsld_func std rightled1 inc countled jsr getData jmp regmain rA5 cmpa #$47 lbne rA6 ldd rightled1 eorb WHITE jsr lsld_func std rightled1 inc countled jsr getData jmp regmain rA6 jmp goaway regdB cmpa #$0B lbne regmain ldaa countled cmpa #$04 lbeq incdrivers ldaa storeinfo rB0 cmpa #$41 lbne rB1 ldd rightled2 eorb BLUE jsr lsld_func std rightled2 inc countled jsr getData jmp regmain rB1 cmpa #$42 lbne rB2 ldd rightled2 eorb GREEN jsr lsld_func std rightled2 inc countled jsr getData jmp regmain rB2 cmpa #$44 lbne rB3 ldd rightled2 eorb RED jsr lsld_func std rightled2 inc countled


F-25

jsr getData jmp regmain rB3 cmpa #$45 lbne rB4 ldd rightled2 eorb MAGENTA jsr lsld_func std rightled2 inc countled jsr getData jmp regmain rB4 cmpa #$46 lbne rB5 ldd rightled2 eorb YELLOW jsr lsld_func std rightled2 inc countled jsr getData jmp regmain rB5 cmpa #$47 lbne rB6 ldd rightled2 eorb WHITE jsr lsld_func std rightled2 inc countled jsr getData jmp regmain rB6 jmp goaway incdrivers inc countdrivers clr countled clr storeinfo jsr getData jmp regmain goaway movw #$0000, frontled1 movw #$0000, frontled2 movw #$0000, backled1 movw #$0000, backled2 movw #$0000, topled1 movw #$0000, topled2 movw #$0000, bottomled1 movw #$0000, bottomled2 movw #$0000, leftled1 movw #$0000, leftled2 movw #$0000, rightled1 movw #$0000, rightled2 clr setled clr countled clr countlights clr countdrivers


F-26

ba1 jsr painting_solved ldaa paint cmpa #$00 bne ba1 rts cmpa #$40 beq donewithreg jmp regmain donewithreg clr countdrivers clr countled clr storeinfo inc paint rts ;*********************************************************************** ;getData getData ldaa #$80 brclr SCISR1,txdre,getData staa SCIDRL brclr SCISR1,rxdrf,getData ldaa SCIDRL cmpa #$01 beq leavedata cmpa #$02 beq leavedata cmpa #$03 beq leavedata cmpa #$04 beq leavedata cmpa #$05 beq leavedata cmpa #$06 beq leavedata cmpa #$C1 beq leavedata cmpa #$C2 beq leavedata cmpa #$C3 beq leavedata cmpa #$41 beq leavedata cmpa #$42 beq leavedata cmpa #$44 beq leavedata cmpa #$45 beq leavedata cmpa #$46


F-27

beq leavedata cmpa #$47 beq leavedata jmp getData leavedata rts ;*********************************************************************** ;PressedLeft ; ; pressedLeft ;the left side button bclr CRGINT,$80 ;rotate the side of the button ;aka the easy part movw #$0000,regholder1 movw #$0000,regholder2 ldd leftled1 std regholder1 ldd leftled2 std regholder2 ldd leftled1 jsr lsld_func jsr lsld_func andb #$00 std leftled1 ldd leftled2 andb #$00 std regholder2 ldd leftled1 eorb regholder2 std leftled1 ldd leftled2 jsr lsld_func jsr lsld_func std leftled2 ldd regholder1 andb #$00 std regholder1 ldd leftled2 eorb regholder1 std leftled2 movw #$0000,regholder1 movw #$0000,regholder2 ;rotate the other sides ldd topled1 std regholder1 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std topled1 ldd backled2 jsr lsrd_func jsr lsld_func


F-28

eorb topled1 std topled1 ldd frontled1 std regholder2 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std frontled1 ldd regholder1 jsr lsrd_func jsr lsld_func eorb frontled1 std frontled1 ldd bottomled2 std regholder1 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std bottomled2 ldd regholder2 jsr lsrd_func jsr lsld_func eorb bottomled2 std bottomled2 ldd backled2 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std backled2 ldd regholder1 jsr lsrd_func jsr lsld_func eorb backled2 std backled2 movw #$0000,regholder1 movw #$0000,regholder2 ldaa #$05 outcharLt brclr SCISR1,txdre,outcharLt staa SCIDRL inc paint bset CRGINT,$80 clr pbC donewithA clr countlights rts ;*********************************************************************** ;PressedRight ; ; pressedRight ;the right side button bclr CRGINT,$80 ;rotate the side of the button ;aka theeasy part movw #$0000,regholder1 movw #$0000,regholder2 ldd rightled1 std regholder1


F-29

ldd rightled2 std regholder2 ldd rightled1 jsr lsld_func jsr lsld_func ldab rightled2 std rightled1 ldd rightled2 jsr lsld_func jsr lsld_func ldab regholder1 std rightled2 movw #$0000,regholder1 movw #$0000,regholder2 ;rotate the other sides ldd topled2 std regholder1 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std topled2 ldd frontled2 jsr lsrd_func jsr lsld_func eorb topled2 std topled2 ldd backled1 std regholder2 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std backled1 ldd regholder1 jsr lsrd_func jsr lsld_func eorb backled1 std backled1 ldd bottomled1 std regholder1 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std bottomled1 ldd regholder2 jsr lsrd_func jsr lsld_func eorb bottomled1 std bottomled1 ldd frontled2 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std frontled2 ldd regholder1


F-30

jsr lsrd_func jsr lsld_func eorb frontled2 std frontled2 movw #$0000,regholder1 movw #$0000,regholder2 ldaa #$06 outcharRt brclr SCISR1,txdre,outcharRt staa SCIDRL inc paint bset CRGINT,$80 clr pbA donewithRight rts ;*********************************************************************** ;PressedTop ; ; pressedTop ;the top side button bclr CRGINT,$80 ;rotate the side of the button ;aka theeasy part movw #$0000,regholder1 movw #$0000,regholder2 ldd topled1 std regholder1 ldd topled2 std regholder2 ldd topled1 jsr lsld_func jsr lsld_func ldab topled2 std topled1 ldd topled2 jsr lsld_func jsr lsld_func ldab regholder1 std topled2 movw #$0000,regholder1 movw #$0000,regholder2 movw #$0000,regholder3 movw #$0000,regholder4 ;rotate the other sides ldd frontled1 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func jsr lsld_func std regholder1 ldd leftled1 std regholder2 jsr lsld_func


F-31

jsr lsrd_func eora regholder1 std leftled1 ldd frontled2 jsr lsld_func jsr lsld_func std regholder1 ldd leftled2 std regholder3 jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func eorb regholder1 std leftled2 ldd regholder2 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func jsr lsld_func std regholder1 ldd backled1 std regholder2 jsr lsld_func jsr lsrd_func eora regholder1 std backled1 ldd regholder3 jsr lsld_func jsr lsld_func std regholder1 ldd backled2 std regholder3 jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func eorb regholder1 std backled2 ldd regholder2 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func jsr lsld_func std regholder1 ldd rightled1 std regholder2 jsr lsld_func jsr lsrd_func eora regholder1 std rightled1 ldd regholder3 jsr lsld_func jsr lsld_func std regholder1 ldd rightled2 std regholder3


F-32

jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func eorb regholder1 std rightled2 ldd regholder2 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func jsr lsld_func std regholder1 ldd frontled1 std regholder2 jsr lsld_func jsr lsrd_func eora regholder1 std frontled1 ldd regholder3 jsr lsld_func jsr lsld_func std regholder1 ldd frontled2 std regholder3 jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func eorb regholder1 std frontled2 ldaa #$03 outcharTop brclr SCISR1,txdre,outcharTop staa SCIDRL inc paint bset CRGINT,$80 clr pbE donewithTop rts ;*********************************************************************** ;PressedBottom ; ; pressedBottom ;the bottom side button bclr CRGINT,$80 ;rotate the side of the button ;aka theeasy part movw #$0000,regholder1 movw #$0000,regholder2 ldd bottomled1 std regholder1 ldd bottomled2 std regholder2


F-33

ldd bottomled1 jsr lsld_func jsr lsld_func ldab bottomled2 std bottomled1 ldd bottomled2 jsr lsld_func jsr lsld_func ldab regholder1 std bottomled2 movw #$0000,regholder1 movw #$0000,regholder2 movw #$0000,regholder3 movw #$0000,regholder4 ;rotate the other sides ldd frontled2 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func jsr lsld_func std regholder1 ldd rightled2 std regholder2 jsr lsld_func jsr lsrd_func eora regholder1 std rightled2 ldd frontled1 jsr lsld_func jsr lsld_func std regholder1 ldd rightled1 std regholder3 jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func eorb regholder1 std rightled1 ldd regholder2 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func jsr lsld_func std regholder1 ldd backled2 std regholder2 jsr lsld_func jsr lsrd_func eora regholder1 std backled2 ldd regholder3


F-34

jsr lsld_func jsr lsld_func std regholder1 ldd backled1 std regholder3 jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func eorb regholder1 std backled1 ldd regholder2 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func jsr lsld_func std regholder1 ldd leftled2 std regholder2 jsr lsld_func jsr lsrd_func eora regholder1 std leftled2 ldd regholder3 jsr lsld_func jsr lsld_func std regholder1 ldd leftled1 std regholder3 jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func eorb regholder1 std leftled1 ldd regholder2 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func jsr lsld_func std regholder1 ldd frontled2 std regholder2 jsr lsld_func jsr lsrd_func eora regholder1 std frontled2 ldd regholder3 jsr lsld_func jsr lsld_func std regholder1 ldd frontled1 std regholder3 jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func


F-35

eorb regholder1 std frontled1 ldaa #$04 outcharBot brclr SCISR1,txdre,outcharBot staa SCIDRL inc paint bset CRGINT,$80 clr pbF donewithBot rts ;*********************************************************************** ;PressedFront ; ; pressedFront ;the front side button bclr CRGINT,$80 ;rotate the side of the button ;aka theeasy part movw #$0000,regholder1 movw #$0000,regholder2 ldd frontled1 std regholder1 ldd frontled2 std regholder2 ldd frontled1 jsr lsld_func jsr lsld_func ldab frontled2 std frontled1 ldd frontled2 jsr lsld_func jsr lsld_func ldab regholder1 std frontled2 movw #$0000,regholder1 movw #$0000,regholder2 movw #$0000,regholder3 movw #$0000,regholder4 ;rotate the other sides ldd bottomled2 std regholder3 ldd bottomled1 std regholder4 ldd topled1 jsr lsld_func jsr lsld_func std regholder1


F-36

ldd topled2 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func eora regholder1 std regholder1 ldd rightled1 std regholder2 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std rightled1 ldd regholder1 eorb rightled1 std rightled1 ldd bottomled1 jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func std bottomled1 ldd regholder2 jsr lsrd_func jsr lsrd_func eora bottomled1 std bottomled1 ldd bottomled2 jsr lsld_func jsr lsrd_func std bottomled2 ldd regholder2 jsr lsrd_func jsr lsld_func jsr lsld_func jsr lsld_func std regholder2 ldd bottomled2 eora regholder2 std bottomled2 ldd regholder4 jsr lsld_func jsr lsld_func std regholder1 ldd regholder3 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func eora regholder1 std regholder1 ldd leftled2 std regholder2 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std leftled2


F-37

ldd regholder1 eorb leftled2 std leftled2 ldd topled1 jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func std topled1 ldd regholder2 jsr lsrd_func jsr lsrd_func eora topled1 std topled1 ldd topled2 jsr lsld_func jsr lsrd_func std topled2 ldd regholder2 jsr lsrd_func jsr lsld_func jsr lsld_func jsr lsld_func std regholder2 ldd topled2 eora regholder2 std topled2 ldaa #$01 outcharFr brclr SCISR1,txdre,outcharFr staa SCIDRL inc paint bset CRGINT,$80 clr pbB donewithFr rts ;*********************************************************************** ;PressedBack ; ; pressedBack ;the back side button bclr CRGINT,$80 ;rotate the side of the button ;aka theeasy part movw #$0000,regholder1 movw #$0000,regholder2 movw #$0000,regholder3 movw #$0000,regholder4 ldd backled1 std regholder1 ldd backled2 std regholder2 ldd backled1 jsr lsld_func jsr lsld_func


F-38

ldab backled2 std backled1 ldd backled2 jsr lsld_func jsr lsld_func ldab regholder1 std backled2 movw #$0000,regholder1 movw #$0000,regholder2 movw #$0000,regholder3 movw #$0000,regholder4 ;rotate the other sides ldd bottomled1 std regholder3 ldd bottomled2 std regholder4 ldd topled2 jsr lsld_func jsr lsld_func std regholder1 ldd topled1 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func eora regholder1 std regholder1 ldd leftled1 std regholder2 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std leftled1 ldd regholder1 eorb leftled1 std leftled1 ldd bottomled2 jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func std bottomled2 ldd regholder2 jsr lsrd_func jsr lsrd_func eora bottomled2 std bottomled2 ldd bottomled1 jsr lsld_func jsr lsrd_func std bottomled1 ldd regholder2 jsr lsrd_func jsr lsld_func jsr lsld_func


F-39

jsr lsld_func std regholder2 ldd bottomled1 eora regholder2 std bottomled1 ldd regholder4 jsr lsld_func jsr lsld_func std regholder1 ldd regholder3 jsr lsrd_func jsr lsrd_func jsr lsrd_func jsr lsld_func eora regholder1 std regholder1 ldd rightled2 std regholder2 jsr lsld_func jsr lsld_func jsr lsld_func jsr lsrd_func std rightled2 ldd regholder1 eorb rightled2 std rightled2 ldd topled2 jsr lsrd_func jsr lsrd_func jsr lsld_func jsr lsld_func std topled2 ldd regholder2 jsr lsrd_func jsr lsrd_func eora topled2 std topled2 ldd topled1 jsr lsld_func jsr lsrd_func std topled1 ldd regholder2 jsr lsrd_func jsr lsld_func jsr lsld_func jsr lsld_func std regholder2 ldd topled1 eora regholder2 std topled1 ldaa #$02 outcharBk brclr SCISR1,txdre,outcharBk staa SCIDRL inc paint bset CRGINT,$80 clr pbD


F-40

donewithBk rts ;*********************************************************************** ;Painter ;This is the main function that paints all our sides ;the based on the values in the driver registers painting_solved bclr CRGINT,$80 ldaa halfsec lbeq done clr halfsec clr TCNT clr TCNT+1 ldaa countdrivers cmpa #$0D lbhs donepainting ldaa PTT eora #$40 staa PTT ldaa countdrivers cmpa #$0C lblo gohere1 ldaa countclk cmpa #$01 lbne gohere1 jmp clearlights gohere1 inc countclk ldaa countclk cmpa #$02 lbne done clr countclk ldaa countdrivers cmpa #$00 lbne driver2 driver1 ldaa PTAD anda #$F0 staa PTAD ldaa setled cmpa #$00 lbne temp1 inc setled ldd rightled1 std temp temp1 ldd temp lsrd std temp lbcc gotozero1 jsr gotoone jmp next11 gotozero1 jsr gotozero next11


F-41

inc countlights ldaa countlights cmpa #$03 bne next12 clr countlights inc countled ldd temp lsrd std temp next12 ldaa countled cmpa #$04 lbeq clearlights jmp done driver2 ldaa countdrivers cmpa #$01 lbne driver3 ldaa PTAD anda #$F0 eora #$01 staa PTAD ldaa setled cmpa #$00 lbne temp2 inc setled ldd rightled2 std temp temp2 ldd temp lsrd std temp lbcc gotozero2 jsr gotoone jmp next21 gotozero2 jsr gotozero next21 inc countlights ldaa countlights cmpa #$03 bne next22 clr countlights inc countled ldd temp lsrd std temp next22 ldaa countled cmpa #$04 lbeq clearlights jmp done driver3 ldaa countdrivers cmpa #$02 lbne driver4 ldaa PTAD anda #$F0 eora #$02 staa PTAD


F-42

ldaa setled cmpa #$00 lbne temp3 inc setled ldd frontled1 std temp temp3 ldd temp lsrd std temp lbcc gotozero3 jsr gotoone jmp next31 gotozero3 jsr gotozero next31 inc countlights ldaa countlights cmpa #$03 bne next32 clr countlights inc countled ldd temp lsrd std temp next32 ldaa countled cmpa #$04 lbeq clearlights jmp done driver4 ldaa countdrivers cmpa #$03 lbne driver5 ldaa PTAD anda #$F0 eora #$03 staa PTAD ldaa setled cmpa #$00 lbne temp4 inc setled ldd frontled2 std temp temp4 ldd temp lsrd std temp lbcc gotozero4 jsr gotoone jmp next41 gotozero4 jsr gotozero next41 inc countlights ldaa countlights cmpa #$03 bne next42 clr countlights inc countled ldd temp


F-43

lsrd std temp next42 ldaa countled cmpa #$04 lbeq clearlights jmp done driver5 ldaa countdrivers cmpa #$04 lbne driver6 ldaa PTAD anda #$F0 eora #$04 staa PTAD ldaa setled cmpa #$00 lbne temp5 inc setled ldd leftled1 std temp temp5 ldd temp lsrd std temp lbcc gotozero5 jsr gotoone jmp next51 gotozero5 jsr gotozero next51 inc countlights ldaa countlights cmpa #$03 bne next52 clr countlights inc countled ldd temp lsrd std temp next52 ldaa countled cmpa #$04 lbeq clearlights jmp done driver6 ldaa countdrivers cmpa #$05 lbne driver7 ldaa PTAD anda #$F0 eora #$05 staa PTAD ldaa setled cmpa #$00 lbne temp6 inc setled ldd leftled2 std temp temp6


F-44

ldd temp lsrd std temp lbcc gotozero6 jsr gotoone jmp next61 gotozero6 jsr gotozero next61 inc countlights ldaa countlights cmpa #$03 bne next62 clr countlights inc countled ldd temp lsrd std temp next62 ldaa countled cmpa #$04 lbeq clearlights jmp done driver7 ldaa countdrivers cmpa #$06 lbne driver8 ldaa PTAD anda #$F0 eora #$06 staa PTAD ldaa setled cmpa #$00 lbne temp7 inc setled ldd backled1 std temp temp7 ldd temp lsrd std temp lbcc gotozero7 jsr gotoone jmp next71 gotozero7 jsr gotozero next71 inc countlights ldaa countlights cmpa #$03 bne next72 clr countlights ldd temp inc countled lsrd std temp next72 ldaa countled cmpa #$04 lbeq clearlights jmp done


F-45

driver8 ldaa countdrivers cmpa #$07 lbne driver9 ldaa PTAD anda #$F0 eora #$07 staa PTAD ldaa setled cmpa #$00 lbne temp8 inc setled ldd backled2 std temp temp8 ldd temp lsrd std temp lbcc gotozero8 jsr gotoone jmp next81 gotozero8 jsr gotozero next81 inc countlights ldaa countlights cmpa #$03 bne next82 clr countlights inc countled ldd temp lsrd std temp next82 ldaa countled cmpa #$04 lbeq clearlights jmp done driver9 ldaa countdrivers cmpa #$08 lbne driverA ldaa PTAD anda #$F0 eora #$08 staa PTAD ldaa setled cmpa #$00 lbne temp9 inc setled ldd topled1 std temp temp9 ldd temp lsrd std temp lbcc gotozero9 jsr gotoone jmp next91 gotozero9 jsr gotozero


F-46

next91 inc countlights ldaa countlights cmpa #$03 bne next92 clr countlights inc countled ldd temp lsrd std temp next92 ldaa countled cmpa #$04 lbeq clearlights jmp done driverA ldaa countdrivers cmpa #$09 lbne driverB ldaa PTAD anda #$F0 eora #$09 staa PTAD ldaa setled cmpa #$00 lbne tempA inc setled ldd topled2 std temp tempA ldd temp lsrd std temp lbcc gotozeroA jsr gotoone jmp nextA1 gotozeroA jsr gotozero nextA1 inc countlights ldaa countlights cmpa #$03 bne nextA2 clr countlights inc countled ldd temp lsrd std temp nextA2 ldaa countled cmpa #$04 lbeq clearlights jmp done driverB ldaa countdrivers cmpa #$0A lbne driverC ldaa PTAD anda #$F0 eora #$0A


F-47

staa PTAD ldaa setled cmpa #$00 lbne tempB inc setled ldd bottomled1 std temp tempB ldd temp lsrd std temp lbcc gotozeroB jsr gotoone jmp nextB1 gotozeroB jsr gotozero nextB1 inc countlights ldaa countlights cmpa #$03 bne nextB2 clr countlights inc countled ldd temp lsrd std temp nextB2 ldaa countled cmpa #$04 lbeq clearlights jmp done driverC ldaa countdrivers cmpa #$0B lbne done ldaa PTAD anda #$F0 eora #$0B staa PTAD ldaa setled cmpa #$00 lbne tempC inc setled ldd bottomled2 std temp tempC ldd temp lsrd std temp lbcc gotozeroC jsr gotoone jmp nextC1 gotozeroC jsr gotozero nextC1 inc countlights ldaa countlights cmpa #$03 bne nextC2 clr countlights inc countled


F-48

ldd temp lsrd std temp nextC2 ldaa countled cmpa #$04 lbeq clearlights jmp done clearlights clr setled clr countled clr countlights movw #$0000, temp inc countdrivers jmp done donepainting clr paint clr setled clr countled clr countlights clr countdrivers movw #$0000, temp ldaa PTAD anda #$F0 eora #$0C staa PTAD bset CRGINT,$80 done rts ;*********************************************************************** ; reset state of cube resetstate movw #$0000, frontled1 movw #$0000, frontled2 movw #$0000, backled1 movw #$0000, backled2 movw #$0000, topled1 movw #$0000, topled2 movw #$0000, bottomled1 movw #$0000, bottomled2 movw #$0000, leftled1 movw #$0000, leftled2 movw #$0000, rightled1 movw #$0000, rightled2 clr paint clr setled clr countled clr countlights clr countdrivers movw #$0000, temp ldd frontled1


F-49

eorb YELLOW jsr lsld_func eorb YELLOW jsr lsld_func eorb YELLOW jsr lsld_func eorb YELLOW std frontled1 ldd frontled2 eorb YELLOW jsr lsld_func eorb YELLOW jsr lsld_func eorb YELLOW jsr lsld_func eorb YELLOW std frontled2 ldd backled1 eorb WHITE jsr lsld_func eorb WHITE jsr lsld_func eorb WHITE jsr lsld_func eorb WHITE std backled1 ldd backled2 eorb WHITE jsr lsld_func eorb WHITE jsr lsld_func eorb WHITE jsr lsld_func eorb WHITE std backled2 ldd topled1 eorb BLUE jsr lsld_func eorb BLUE jsr lsld_func eorb BLUE jsr lsld_func eorb BLUE std topled1 ldd topled2 eorb BLUE jsr lsld_func eorb BLUE jsr lsld_func eorb BLUE jsr lsld_func eorb BLUE std topled2 ldd bottomled1 eorb GREEN jsr lsld_func eorb GREEN jsr lsld_func eorb GREEN jsr lsld_func eorb GREEN std bottomled1 ldd bottomled2


F-50

eorb GREEN jsr lsld_func eorb GREEN jsr lsld_func eorb GREEN jsr lsld_func eorb GREEN std bottomled2 ldd leftled1 eorb RED jsr lsld_func eorb RED jsr lsld_func eorb RED jsr lsld_func eorb RED std leftled1 ldd leftled2 eorb RED jsr lsld_func eorb RED jsr lsld_func eorb RED jsr lsld_func eorb RED std leftled2 ldd rightled1 eorb MAGENTA jsr lsld_func eorb MAGENTA jsr lsld_func eorb MAGENTA jsr lsld_func eorb MAGENTA std rightled1 ldd rightled2 eorb MAGENTA jsr lsld_func eorb MAGENTA jsr lsld_func eorb MAGENTA jsr lsld_func eorb MAGENTA std rightled2 inc paint reset1 jsr painting_solved ldaa paint cmpa #$00 bne reset1 rts ;***********************************************************************


F-51

; GotoZero sets output to zero gotozero ldaa PTT anda #$80 cmpa #$80 bne done1 ldaa PTT eora #$80 staa PTT done1 rts ;*********************************************************************** ; GotoOne sets output to one gotoone ldaa PTT anda #$80 cmpa #$80 beq done2 ldaa PTT eora #$80 staa PTT done2 rts ;*********************************************************************** ; ; RTI interrupt service routine ; ; Initialized for 2.048 ms interrupt rate ; ; Samples state of pushbuttons (PAD7 = left, PAD6 = right) ; ; If change in state from "high" to "low" detected, set pushbutton flag ; leftpb (for PAD7 H -> L), rghtpb (for PAD6 H -> L) ; Recall that pushbuttons are momentary contact closures to ground ; ; Also, increments 2-byte variable "random" each time interrupt occurs ; NOTE: Will need to truncate "random" to 12-bits to get a reasonable delay ; rti_isr bset crgflg,$80 contin ldaa PTT anda #$3F cmpa prevpb beq rti_exit staa prevpb lsra lbcs bpb inc pbA bpb lsra lbcs cpb inc pbB cpb lsra


F-52

lbcs dpb inc pbC dpb lsra lbcs epb inc pbD epb lsra lbcs fpb inc pbE fpb lsra bcs rti_exit inc pbF rti_exit rti ;*********************************************************************** ; Left Shift function lsld_func lsld lsld lsld lsld rts ;*********************************************************************** ; Right Shift function lsrd_func lsrd lsrd lsrd lsrd rts ;*********************************************************************** ; ; TIM interrupt service routine ; ; Initialized for 1.00 ms interrupt rate ; tim_isr bset TFLG1,$80 inc onecnt ldaa onecnt cmpa #!1 bne tim_exit clr onecnt inc halfsec tim_exit rti ;***********************************************************************


F-53

; ; *** NOTE *** Add any other routines you deem necessary ; ;*********************************************************************** ; ; Define 'where you want to go today' (reset and interrupt vectors) ; ; If get a "bad" interrupt, just return from it BadInt rti ; ------------------ VECTOR TABLE -------------------- org $FF8A fdb BadInt ;$FF8A: VREG LVI fdb BadInt ;$FF8C: PWM emergency shutdown fdb BadInt ;$FF8E: PortP fdb BadInt ;$FF90: Reserved fdb BadInt ;$FF92: Reserved fdb BadInt ;$FF94: Reserved fdb BadInt ;$FF96: Reserved fdb BadInt ;$FF98: Reserved fdb BadInt ;$FF9A: Reserved fdb BadInt ;$FF9C: Reserved fdb BadInt ;$FF9E: Reserved fdb BadInt ;$FFA0: Reserved fdb BadInt ;$FFA2: Reserved fdb BadInt ;$FFA4: Reserved fdb BadInt ;$FFA6: Reserved fdb BadInt ;$FFA8: Reserved fdb BadInt ;$FFAA: Reserved fdb BadInt ;$FFAC: Reserved fdb BadInt ;$FFAE: Reserved fdb BadInt ;$FFB0: CAN transmit fdb BadInt ;$FFB2: CAN receive fdb BadInt ;$FFB4: CAN errors fdb BadInt ;$FFB6: CAN wake-up fdb BadInt ;$FFB8: FLASH fdb BadInt ;$FFBA: Reserved fdb BadInt ;$FFBC: Reserved fdb BadInt ;$FFBE: Reserved fdb BadInt ;$FFC0: Reserved fdb BadInt ;$FFC2: Reserved fdb BadInt ;$FFC4: CRG self-clock-mode fdb BadInt ;$FFC6: CRG PLL Lock fdb BadInt ;$FFC8: Reserved fdb BadInt ;$FFCA: Reserved fdb BadInt ;$FFCC: Reserved fdb BadInt ;$FFCE: PORTJ fdb BadInt ;$FFD0: Reserved fdb BadInt ;$FFD2: ATD fdb BadInt ;$FFD4: Reserved fdb BadInt ;$FFD6: SCI Serial System fdb BadInt ;$FFD8: SPI Serial Transfer Complete fdb BadInt ;$FFDA: Pulse Accumulator Input Edge fdb BadInt ;$FFDC: Pulse Accumulator Overflow fdb BadInt ;$FFDE: Timer Overflow fdb tim_isr ;$FFE0: Standard Timer Channel 7 fdb BadInt ;$FFE2: Standard Timer Channel 6 fdb BadInt ;$FFE4: Standard Timer Channel 5 fdb BadInt ;$FFE6: Standard Timer Channel 4 fdb BadInt ;$FFE8: Standard Timer Channel 3


F-54

fdb BadInt ;$FFEA: Standard Timer Channel 2 fdb BadInt ;$FFEC: Standard Timer Channel 1 fdb BadInt ;$FFEE: Standard Timer Channel 0 fdb rti_isr ;$FFF0: Real Time Interrupt (RTI) fdb BadInt ;$FFF2: IRQ (External Pin or Parallel I/O) (IRQ) fdb BadInt ;$FFF4: XIRQ (Pseudo Non-Maskable Interrupt) (XIRQ) fdb BadInt ;$FFF6: Software Interrupt (SWI) fdb BadInt ;$FFF8: Illegal Opcode Trap () fdb startup ;$FFFA: COP Failure (Reset) () fdb BadInt ;$FFFC: Clock Monitor Fail (Reset) () fdb startup ;$FFFE: /RESET end


F-55

// Rubik's Cube simulator import java.awt.*; import java.awt.event.*; import java.io.*; import java.net.*; import java.applet.Applet; import java.lang.*; import java.text.*; import java.util.*; public final class Cubie extends java.applet.Applet implements ActionListener, ItemListener, Runnable { final int NUMGROUPS = 3; final int NUMVIEWS = 4; final int VIEWWIDTH = 300; final int VIEWHEIGHT = 350; Settings settings = new Settings(); int symType = 0; int viewer = 0; boolean checker = false; Viewer cubeViewers[] = { new Viewer3D(VIEWWIDTH ,VIEWHEIGHT,settings,this), new ViewerDiag(VIEWWIDTH ,VIEWHEIGHT,settings,this), new ViewerBox(VIEWWIDTH ,VIEWHEIGHT,settings,this), new ViewerFlat(VIEWWIDTH ,VIEWHEIGHT,settings,this) }; Panel rightPanel = new Panel(); //Button mixBut = new Button("Mix"); Button resetBut = new Button("Reset"); Button solveBut = new Button("Step"); Panel boxPanel = new Panel(); TabSet tabSet; Panel tabPanel[] = { new Panel(),new Panel() }; CheckboxGroup cubeGroup = new CheckboxGroup(); Checkbox groupRadioBox[] = { new Checkbox("Play",cubeGroup,false), new Checkbox("Paint",cubeGroup,false), new Checkbox("Help",cubeGroup,false) }; Solver solvers[] = { new SolverKociemba(this), new SolverSquare(this), new SolverSlice(this), new SolverAntiSlice(this), new SolverTwoGen(this) }; Color colors[] = { new Color(255,0,0), //unprepared new Color(192,192,192), //prepared, ready, controls background color new Color(0,255,0), //Running solver new Color(255,255,255), // viewer background color }; boolean solution=true; boolean symTwoCol=false;


F-56

MoveSequence generator; int seqPos=0; boolean playFw=true; boolean moveInProgress=false; String simplify_solution = ""; String[] solution_char; Vector solution_command = new Vector(); // applet control boolean isPlaying=false; boolean isSolved = true; //TCI/IP control static private boolean isapplet = true; static private InetAddress arg_ip = null; static private int arg_port = 0; public tcpip gtp = null;; InetAddress reader_ip = null; int port = 10001; public void init() { int i,d,x,y; final int vw=VIEWWIDTH,vh=VIEWHEIGHT,gw=220,bw=gw/4,th=50,bh=20,bw2=75,bh2=16; // build main applet panel setLayout(null); setBackground(colors[3]); add(rightPanel); add(boxPanel); for( i=0; i<NUMVIEWS; i++) { add(cubeViewers[i]); cubeViewers[i].setBounds(0,0,vw,vh); cubeViewers[i].setVisible(i==0); cubeViewers[i].setBackground(colors[3]); } rightPanel.setBounds(vw,0,gw,vh); boxPanel.setBounds(0,vh,vw+gw,th); //build right panel rightPanel.setLayout(null); rightPanel.setBackground(colors[3]); //rightPanel.add(mixBut); //mixBut.setBounds(3*bw,6*bh,bw,bh); rightPanel.add(resetBut); resetBut.setBounds(3*bw,6*bh,bw,bh); rightPanel.add(solveBut); solveBut.setBounds(3*bw,8*bh,bw,bh); //mixBut.setEnabled(false); resetBut.setEnabled(false); solveBut.setEnabled(false); groupRadioBox[0].addItemListener(this); groupRadioBox[1].addItemListener(this); groupRadioBox[2].addItemListener(this); rightPanel.add(groupRadioBox[0]); groupRadioBox[0].setBounds(bw,4*bh,bw,20); groupRadioBox[0].setBackground(colors[3]); rightPanel.add(groupRadioBox[1]); groupRadioBox[1].setBounds(bw,6*bh,bw,20); groupRadioBox[1].setBackground(colors[3]); rightPanel.add(groupRadioBox[2]); groupRadioBox[2].setBounds(bw,8*bh,bw,20); groupRadioBox[2].setBackground(colors[3]);


F-57

// add all right panel listeners //mixBut.addActionListener(this); resetBut.addActionListener(this); solveBut.addActionListener(this); // Build set of tabpanels tabSet = new TabSet(this,new Color(128,128,128),colors[1]); rightPanel.add(tabSet); tabSet.setBounds(0,bh+1,gw,bh-1); for( i=0; i<1; i++) { tabPanel[i].setLayout(null); tabPanel[i].setBounds(0,bh+bh,gw,vh-bh-bh-bh-2); tabPanel[i].setBackground(colors[1]); } // build group tab panel d=tabPanel[0].getSize().height/(NUMGROUPS*2+3); Label l=new Label("Current:"); l.setBounds(0,0,bw,d+d); tabPanel[1].add(l); l=new Label("Selected:"); l.setBounds(bw+bw,0,bw,d+d); tabPanel[1].add(l); // initialise all solvers for( i=0; i<NUMGROUPS; i++) { solvers[i].settings(settings); new Thread(solvers[i]).start(); } cubeViewers[viewer].repaint(); updateStatus(false); // **** WiPort control **** try { reader_ip = InetAddress.getByName(getCodeBase().getHost()); } catch (UnknownHostException e){} if (reader_ip != null) { if (gtp == null) { gtp = new tcpip(reader_ip, port); if (gtp.s == null) { // failed socket connection message gtp = null; } else { // successful socket connection message } } } // **** WiPort control **** }


F-58

public void stop() { //tell thread to stop if( isPlaying ) { isPlaying = false; while(moveInProgress) { try { Thread.sleep( 50 ); } catch ( Exception ignored ) {} } settings.lockViewer=false; } } public void run() { int f,q, receive; isPlaying=true; settings.lockViewer=true; do{ if(groupRadioBox[0].getState()) { receive = receiveCommand(); if(receive == 0x01) { cubeViewers[viewer].showMove(2,1); sendCommand(0x01); } if(receive == 0x02) { cubeViewers[viewer].showMove(5,1); sendCommand(0x02); } if(receive == 0x03) { cubeViewers[viewer].showMove(1,1); sendCommand(0x03); } if(receive == 0x04) { cubeViewers[viewer].showMove(4,1); sendCommand(0x04); } if(receive == 0x05) { cubeViewers[viewer].showMove(0,1); sendCommand(0x05); } if(receive == 0x06) { cubeViewers[viewer].showMove(3,1); sendCommand(0x06); } } else if(groupRadioBox[2].getState()) { if(solution_command.size() == 0) { solveBut.setEnabled(false); } }


F-59

if( isPlaying ) { try { Thread.sleep( 500 ); } catch ( Exception ignored ) {} do { try { Thread.sleep( 50 ); } catch ( Exception ignored ) {} }while(moveInProgress); } }while(isPlaying); settings.lockViewer=false; } private void updateStatus(boolean changed) { // Update status of current tab and solver buttons boolean t; if(tabSet.getTab()==0){ boolean currentSolvable=false; t=solvers[0].setPosition( settings.cubePos, true ); currentSolvable=t; int c=1; if( !solvers[0].isPrepared()) c=0; else if( solvers[0].isRunning()) c=2; t=solvers[settings.group].isPrepared() && currentSolvable ; } else { t=solvers[0].setPosition( settings.cubePos, true ); t=solvers[0].isPrepared() && t; } checker = t; //solveBut.setLabel( settings.solving ? "Stop": "Step"); } public void destroy() { // **** WiPort control **** if (gtp != null) { gtp.disconnect(); } gtp = null; // **** WiPort control **** stop(); if( settings.solving ) { //tell solver to stop solvers[settings.group].stopSolving(); //wait till it has indeed stopped while( settings.solving ) { try {


F-60

Thread.sleep( 100 ); } catch ( Exception ignored ) {} }; } for(int i=0; i<NUMVIEWS; i++) { remove( cubeViewers[i] ); } remove( rightPanel ); remove( boxPanel ); } public String getAppletInfo() { return "Title: Cubie \nAuthor: Jaap Scherphuis"; } //--- button action/listening routines --- public void solve() { if( settings.solving ) { for(int i=0; i<NUMGROUPS; i++) solvers[i].stopSolving(); } else if( solvers[0].setPosition( settings.cubePos, false ) ) { startSolving(); new Thread(solvers[0]).start(); } } public void actionPerformed(ActionEvent e) { int i; int next_command; Object src = e.getSource(); /*if ( src == mixBut ) { if( !settings.solving ) { //stop();// stop any animation if(tabSet.getTab()==0) { solvers[0].mix(settings.cubePos); } else { settings.cubePos.mix(symType, settings.superGroup,symTwoCol); } setSequencePosition(-1); generator = null; updateStatus(true); cubeViewers[3].repaint(); settings.cubePos.getFaceletColors(); sendNewColors(); } }*/ if ( src == resetBut ) {


F-61

if( !settings.solving ) { stop();// stop any animation settings.cubePos.reset(); setSequencePosition(-1); generator = null; updateStatus(true); cubeViewers[3].repaint(); //settings.cubePos.getFaceletColors(); sendCommand(0x40); //sendNewColors(); } } else if ( src == solveBut ) { //System.out.println("Removed command: " + solution_command.get(0)); next_command = Integer.parseInt((solution_command.remove(0)).toString()); System.out.println("Next command: " + next_command); sendCommand(next_command); stepBackward(); //solveBut.setEnabled(false); new Thread(this).start(); } else { // check for viewer actions for(i=0;i<NUMVIEWS;i++) { if( src==cubeViewers[i] ) { System.out.println("source is cubeViewers[" + i + "]"); updateStatus(true); if( e.getActionCommand()=="user" ) { System.out.println("command action is user"); seqPos=-1; settings.cubePos.getFaceletColors(); //sendNewColors(); } else { //System.out.println("command action not user"); moveInProgress=false; } return; } } // check for solver actions for(i=0;i<NUMGROUPS;i++) { if( src==solvers[i] ) { if(e.getActionCommand()=="a") { //System.out.println("command action is a"); //init done }


F-62

else if(e.getActionCommand()=="b") { //solution found //System.out.println("command action is b"); stoppedSolving(); generator = settings.generator; settings.generator=null; seqPos = generator.getLength(); settings.cubePos.doSequence( generator ); } else if(e.getActionCommand()=="c") { //aborted solve //System.out.println("command action is c"); stoppedSolving(); } else if(e.getActionCommand()=="d") { //ended solve //System.out.println("command action is d"); stoppedSolving(); } else if(e.getActionCommand()=="e") { //started solve //System.out.println("command action is e"); } updateStatus(false); return; } } } } // enable all buttons void stoppedSolving() { settings.lockViewer =false; } // disable all buttons void startSolving() { settings.lockViewer=true; //mixBut.setEnabled(false); resetBut.setEnabled(false); } private void stepForward() { if( isPlaying ) { stop(); } else if( generator!=null && seqPos<generator.getLength() ) { if( seqPos<0 ) setSequencePosition(0); int f=generator.getMoves()[seqPos]; int q=generator.getAmount()[seqPos]; if( cubeViewers[viewer].showMove(f,q) ) seqPos++;


F-63

} } private void stepBackward() { if( generator!=null ) { if( seqPos<0 ) setSequencePosition(generator.getLength()); if( seqPos>0 ) { seqPos--; int f=generator.getMoves()[seqPos]; int q=generator.getAmount()[seqPos]; if(! cubeViewers[viewer].showMove(f,4-q) ) { seqPos++; } } } } private void playForward() { if( isPlaying ) { stop(); } else if( generator!=null && seqPos<generator.getLength() ) { if( seqPos<0 ) setSequencePosition(0); playFw=true; new Thread(this).start(); } } private void playBackward() { if( isPlaying ) { stop(); } else if( generator!=null ) { if( seqPos<0 ) setSequencePosition(generator.getLength()); if( seqPos>0 ) { playFw=false; new Thread(this).start(); } } } private void setSequencePosition(int p) { if( generator==null ) { seqPos=-1; } else { if( p>generator.getLength() ) p=generator.getLength(); seqPos = p; if( p>=0 ) settings.cubePos.doSequence( generator, p );


F-64

updateStatus(true); } } public void itemStateChanged(ItemEvent e) { int g, x; int i = 0; Object src = e.getSource(); //new Thread(this).start(); for( g=0;g<NUMGROUPS; g++) { if( src == groupRadioBox[g] ) { settings.group=g; //now set box to reflect actual choice of group if(src == groupRadioBox[0] ) { System.out.println("Play Mode"); //mixBut.setEnabled(false); resetBut.setEnabled(false); solveBut.setEnabled(false); settings.edit = false; for(x=0;x<NUMVIEWS;x++) { cubeViewers[x].setVisible(x==0); } sendCommand(0xC1); new Thread(this).start(); } else if(src == groupRadioBox[1] ) { System.out.println("Paint Mode"); //mixBut.setEnabled(true); resetBut.setEnabled(true); solveBut.setEnabled(false); settings.edit = true; for(x=0;x<NUMVIEWS;x++) { cubeViewers[x].setVisible(x==3); } sendCommand(0xC2); stop(); } else if(src == groupRadioBox[2] ) { System.out.println("Help Mode"); generator = null; stop();// stop any animation solve(); while(generator == null) { } //System.out.println(""+generator.toString(solution,seqPos)); simplify_solution = ""; simplifySolution(); //mixBut.setEnabled(false); resetBut.setEnabled(false); if(generator.getLength() == 0) {


F-65

solveBut.setEnabled(false); } else { solveBut.setEnabled(true); } settings.edit = false; solvers[0].setPosition(settings.cubePos, false); for(x=0;x<NUMVIEWS;x++) { cubeViewers[x].setVisible(x==0); } sendCommand(0xC3); new Thread(this).start(); } //update (group solvability flags and) solve button updateStatus(false); return; } } } // **** WiPort control **** private void sendCommand(int command) { String command_s = new Character((char)command).toString(); if((command_s.length() != 0) && (gtp != null)) { gtp.send(command_s); } } private int receiveCommand() { byte[] in; String command_s = ""; //cubeViewers[viewer].showMove(0,1); if((gtp != null) && (gtp.available() > 0)) { in = gtp.receive(); command_s = new String(in); int command = (int)command_s.charAt(0); return command; } return 0; } // **** WiPort control **** private void sendNewColors() { int[] color_order = {18,21,24,25,26,23,20,19, 45,48,51,52,53,50,47,46, 9,12,15,16,17,14,11,10, 44,41,38,37,36,39,42,43, 0,3,6,7,8,5,2,1, 27,30,33,34,35,32,29,28};


F-66

int i; int j = 0; int response = 0; for(i = 0; i < 48; i++) { if(i % 8 == 0) { System.out.println("Side " + (i / 8 + 1)); } if(settings.cubePos.faceletColor[color_order[i]] == 0) { //Send Red sendCommand(0x44); System.out.println("Red"); } else if(settings.cubePos.faceletColor[color_order[i]] == 1) { //Send Blue sendCommand(0x41); System.out.println("Blue"); } else if(settings.cubePos.faceletColor[color_order[i]] == 2) { //Send Yellow sendCommand(0x46); System.out.println("Yellow"); } else if(settings.cubePos.faceletColor[color_order[i]] == 3) { //Send Magenta sendCommand(0x45); System.out.println("Magenta"); } else if(settings.cubePos.faceletColor[color_order[i]] == 4) { //Send Green sendCommand(0x42); System.out.println("Green"); } else if(settings.cubePos.faceletColor[color_order[i]] == 5) { //Send White sendCommand(0x47); System.out.println("White"); } response = receiveCommand(); while(response == 0x00 && j < 1000) { //System.out.println("Waiting for receive command " + j); j++; response = receiveCommand(); } j=0; } sendCommand(0x40); }


F-67

private void simplifySolution() { int i; int j = -1; int size; simplify_solution = ""; solution_command.removeAllElements(); simplify_solution = generator.toString(solution,seqPos); solution_char = simplify_solution.split(" "); simplify_solution = ""; for(i = 0; i < solution_char.length; i++) { //Single face turns if(solution_char[i].equals("F")) { simplify_solution += "F "; solution_command.add(j, 0x01); } else if(solution_char[i].equals("B")) { simplify_solution += "B "; solution_command.add(j, 0x02); } else if(solution_char[i].equals("U")) { simplify_solution += "U "; solution_command.add(j, 0x03); } else if(solution_char[i].equals("D")) { simplify_solution += "D "; solution_command.add(j, 0x04); } else if(solution_char[i].equals("L")) { simplify_solution += "L "; solution_command.add(j, 0x05); } else if(solution_char[i].equals("R")) { simplify_solution += "R "; solution_command.add(j, 0x06); } //Double face turns else if(solution_char[i].equals("F2")) { simplify_solution += "F F "; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x01); } else if(solution_char[i].equals("B2")) { simplify_solution += "B B "; solution_command.add(j, 0x02); j++; solution_command.add(j, 0x02); } else if(solution_char[i].equals("U2")) { simplify_solution += "U U ";


F-68

solution_command.add(j, 0x03); j++; solution_command.add(j, 0x03); } else if(solution_char[i].equals("D2")) { simplify_solution += "D D "; solution_command.add(j, 0x04); j++; solution_command.add(j, 0x04); } else if(solution_char[i].equals("L2")) { simplify_solution += "L L "; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x05); } else if(solution_char[i].equals("R2")) { simplify_solution += "R R "; solution_command.add(j, 0x06); j++; solution_command.add(j, 0x06); } //Triple face turns else if(solution_char[i].equals("F'")) { simplify_solution += "F F F "; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x01); } else if(solution_char[i].equals("B'")) { simplify_solution += "B B B "; solution_command.add(j, 0x02); j++; solution_command.add(j, 0x02); j++; solution_command.add(j, 0x02); } else if(solution_char[i].equals("U'")) { simplify_solution += "U U U "; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x03); } else if(solution_char[i].equals("D'")) { simplify_solution += "D D D "; solution_command.add(j, 0x04); j++; solution_command.add(j, 0x04); j++; solution_command.add(j, 0x04); } else if(solution_char[i].equals("L'"))


F-69

{ simplify_solution += "L L L "; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x05); } else if(solution_char[i].equals("R'")) { simplify_solution += "R R R "; solution_command.add(j, 0x06); j++; solution_command.add(j, 0x06); j++; solution_command.add(j, 0x06); } else if(solution_char[i].equals("Fs")) { simplify_solution += "F B B B "; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x02); j++; solution_command.add(j, 0x02); j++; solution_command.add(j, 0x02); } else if(solution_char[i].equals("Us")) { simplify_solution += "U D D D "; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x04); j++; solution_command.add(j, 0x04); j++; solution_command.add(j, 0x04); } else if(solution_char[i].equals("Ls")) { simplify_solution += "L R R R "; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x06); j++; solution_command.add(j, 0x06); j++; solution_command.add(j, 0x06); } else if(solution_char[i].equals("Fs2")) { simplify_solution += "F F B B "; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x02); j++; solution_command.add(j, 0x02); } else if(solution_char[i].equals("Us2")) {


F-70

simplify_solution += "U U D D "; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x04); j++; solution_command.add(j, 0x04); } else if(solution_char[i].equals("Ls2")) { simplify_solution += "L L R R "; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x06); j++; solution_command.add(j, 0x06); } else if(solution_char[i].equals("Fs'")) { simplify_solution += "F F F B "; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x02); } else if(solution_char[i].equals("Us'")) { simplify_solution += "U U U D "; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x04); } else if(solution_char[i].equals("Ls'")) { simplify_solution += "L L L R "; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x06); } else if(solution_char[i].equals("Fa")) { simplify_solution += "F B "; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x02); } else if(solution_char[i].equals("Ua")) { simplify_solution += "U D ";


F-71

solution_command.add(j, 0x03); j++; solution_command.add(j, 0x04); } else if(solution_char[i].equals("La")) { simplify_solution += "L R "; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x06); } else if(solution_char[i].equals("Fa2")) { simplify_solution += "F F B B "; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x02); j++; solution_command.add(j, 0x02); } else if(solution_char[i].equals("Ua2")) { simplify_solution += "U U D D "; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x04); j++; solution_command.add(j, 0x04); } else if(solution_char[i].equals("La2")) { simplify_solution += "L L R R "; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x06); j++; solution_command.add(j, 0x06); } else if(solution_char[i].equals("Fa'")) { simplify_solution += "F F F B B B "; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x01); j++; solution_command.add(j, 0x02); j++; solution_command.add(j, 0x02); j++; solution_command.add(j, 0x02); } else if(solution_char[i].equals("Ua'")) { simplify_solution += "U U U D D D "; solution_command.add(j, 0x03);


F-72

j++; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x03); j++; solution_command.add(j, 0x04); j++; solution_command.add(j, 0x04); j++; solution_command.add(j, 0x04); } else if(solution_char[i].equals("La'")) { simplify_solution += "L L L R R R "; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x05); j++; solution_command.add(j, 0x06); j++; solution_command.add(j, 0x06); j++; solution_command.add(j, 0x06); } j++; } //System.out.println("Simple solution: " + simplify_solution); /*for(i = 0; i < solution_command.size(); i++) { System.out.println(solution_command.get(i)); }*/ seqPos = simplify_solution.length()/2; generator.parse(simplify_solution,true); } }


G-1

Appendix G: FMECA Worksheet Failure

No. Failure Mode Possible Causes Failure Effects Method of

Detection Criticality Remarks

A1

Unable to program the

microcontroller

Fried micro, Oscillator circuit failure, no power

The microcontroller

can not be updated

Observation, BDM

programming does not work

L2 This will cause complete or partial

failure of the RoboRubik

A2

Unable to serially communicate

with the microcontroller

bad or damaged traces, incorrect serial

initialization, damaged block in

micro

The micro and the WiPort can not keep up to date with each other

The RoboRubik and the web applet do not

stay synchronized

L2 This will cause partial failure of the RoboRubik.

A3

Over-voltage on power line

bad LDO Unable to communicate

with the micro, odd functionality

Observation, measure with

DMM

L2 3.3 V is what the power line should be. If 6 V

then there is a problem with the LDO. Most likely to fry micro.

A4

Under-voltage on power line

bad LDO, short from bypass capacitor

Unable to communicate

with the micro, odd functionality


DMM

L2 3.3 V is what the power line should be. Most likely will cause the micro to not work or

have odd func.

B1

Unable to connect to the RoboRubik

via wireless connection

The WiPort is not powered due to bypass capacitor short. IC may be

fried.

The user is unable to use the website

and solver aid mode.

Observation L2 WiPort is very complicated and can have many things go

wrong internally


G-2

C1

incorrect voltage on input power

line

wrong battery, battery is low

damage to the LDO, not enough

power for the other components


DMM

L2 The LDO can handle up to 35 V input. Most likely cause is low

battery.

C2

Under-voltage on output

There is a short between the power

and ground somewhere on the board, low battery

Not able to communicate with anything,

nothing is powered, odd functionality

Observation, measure with DMM, LDO gets very hot

L1 Will cause the batteries to get very hot. Leakage

may occur but most likely batteries will just

be depleted.

D1

Partial LED functionality

Some of the pins are fried on the driver,

possible under-voltage on power line

due to bad LDO, external resistor

failure

RoboRubik has a few LEDs not

working


DMM

L2 Low battery seems to cause very odd

functionality with the drivers.

D2

Bright LEDs The IC is fried, possible over-voltage

on power line, external resistor

failure

LEDs get really bright and

possibly hurt retinas of user.

Observation L1 This risk was decreased but putting more

diffusing material in front of the LEDs. This

is very unlikely to occur.

Documents

ECE 477 Final Report Spring 2008 Team 11 RoboRubik€¦ · ECE 477 Final Report Spring 2008 -1- Abstract The following information in this report will describe the design process