Purdue University
ECE 477 Final Report ( Spring 2008
Team 11 ( RoboRubik
[pic]
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 | |
| |
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 |
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.
[pic]
Figure 1-1: RoboRubik Project
[pic]
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.
• 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.
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.
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. 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.
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. 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.
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.
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 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.
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 |2000 Flash |
| | | |300 inactive |256 RAM |
| MatchPort |45 x 45 x 10.4 * |328 indoors |740 active |2000 Flash |
| | | |250 inactive |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 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
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.
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 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.
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 |
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 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.
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 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.
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 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 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].
[pic] [pic]
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 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.
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, 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 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].
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.
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 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.
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.
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.
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.
9. 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.
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 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.
[pic]
Figure 10-1: Hierarchical Block Diagram
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.
10. 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.
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.
References
1] “16-bit Microcontrollers MC9S12C32,” [Online document], [cited 2008 Jan 29], Available HTTP:
2] “RECOM Power Inc. – Our DC/DC Highseller,” [Online document], [cited 2008 Jan 29], Available HTTP:
3] “Allegro | Product | A6276 16-Bit Serial-Input, Constant Current Latched LED Driver,” [Online document], [cited 2008 Jan 29], Available HTTP:
4] “TT Electronics plc,” [Online document], [cited 2008 Jan 29], Available HTTP:
5] “WiPort – Embedded 802.11, Embedded Ethernet, 802.11g,” [Online document], [cited 2008 Jan 29], Available HTTP:
6] “Rubik’s Official Online Site,” [Online document], [cited 2008 Jan 29], Available HTTP:
7] “WiPort vs. MatchPort B/G Compared,” [Online document], [cited 2008 Jan 29], Available HTTP:
8] “MC9S12C128 Product Summary Page,” [Online document], [cited 2008 Jan 29], Available HTTP:
9] United States Patent and Trademark Office Patent #6,974,130, [Online document], 2005 Dec, [cited 2008 Mar 27], Available HTTP:
10] United States Patent and Trademark Office Patent #5,310,183, [Online document], 1994 May, [cited 2008 Mar 27], Available HTTP:
11] United States Patent and Trademark Office Patent #5,651,715, [Online document], 1997 July, [cited 2008 Mar 27], Available HTTP:
12] MIL-HDBK-217F, United States Department of Defense, 2 January 1990.
13] “Optek OVSRRGBCC3 Datasheet” [Online document], [cited 2008 Apr 28] Available
HTTP:
14] Martin Tarr, "PCB recycling issues", [Online Document] [cited 2008 Apr 28] Available HTTP:
15] “Waste Minimization Assessment for a Printed Circuit Board Manufacturer,” Looby and Kirsch. [Online Document], [cited 2008 Apr 28] Available HTTP: .
16] Wikipedia, "Restriction of Hazardous Substances Directive", [Online Document] [cited 2008 Apr 28] Available HTTP:
17] “ICER: Industry Council for Electronic Equipment Recycling”, [Online Document] [cited 2008 Apr 28] Available HTTP:
18] “Eastern Environmental”, [Online Document] [cited 2008 Apr 28] Available HTTP:
19] “Rubik’s Official Online Site,” [Online document], [cited 2008 Feb 08], Available HTTP:
20] “Rubik’s Revolution Official Online Site,” [Online document], [cited 2008 Feb 08], Available HTTP:
21] “Plexiglas Optical and Transmission Characteristics,” [Online document], [cited 2008 Feb 08], Available HTTP:
22] “Energizer 6V EL2CR5 Lithium” [Online document], [cited 2008 Apr 28] Available
HTTP:
23] “Fairchild KA378R33 Datasheet” [Online document], [cited 2008 Apr 28] Available HTTP:
24] “MC9S12C Family User Guide” [Online document], [cited 2008 Apr 28], Available
HTTP:
25] “Lantronix WiPort Datasheet” [Online document], [cited 2008 Apr 28], Available
HTTP:
26] “Lantronix WiPort User Guide” [Online document], [cited 2008 Apr 28] Available
HTTP:
27] “Allegro A6279 Datasheet” [Online document], [cited 2008 Apr 28] Available
HTTP:
28] “MC9S12C Family User Guide” [Online document], [cited 2008 Feb 22], Available
HTTP:
29] “Lantronix WiPort Integration Guide” [Online document], [cited 2008 Feb 22], Available
HTTP:
30] “NKK Series CB3 Pushbutton Datasheet“[Online document], [cited 2008 Feb 22] Available
HTTP: pdf/CB3.pdf
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. 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 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; 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 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.
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.
Appendix B: Packaging
[pic]
Figure B-1: Cut-Away Internal View
[pic]
Figure B-2: Exploded Individual Side View
Appendix C: Schematic
[pic]
Figure C-1: Schematic for Main PCB
[pic]
Figure C-2: Schematic for Side PCBs
Appendix D: PCB Layout Top and Bottom Copper
.
[pic]
Figure D-1: PCB Layout for Main PCB
[pic]
Figure D-2: PCB Layout for Side PCBs
Appendix E: Parts List Spreadsheet
|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 |
Table E-1: Parts List
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
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
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
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)
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
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
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
; - 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
;***********************************************************************
; 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
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
;***********************************************************************
;
; *** 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
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
// Rubik's Cube simulator
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import .*;
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;
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 ................
................
In order to avoid copyright disputes, this page is only a partial summary.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.
Related searches
- purdue mla citation generator
- purdue owl mla works cited generator
- purdue owl apa outline template
- purdue owl apa outline example
- purdue owl outline format
- purdue owl works cited generator
- purdue owl mla outline sample
- purdue owl apa format template
- purdue owl sample mla essay
- purdue owl website
- purdue owl mla citation machine
- owl purdue outline template