The "Electric Etch" project takes the classic Etch-a-Sketch® toy and turns it into a non-volatile, continuous-line display capable of drawing the current time and text messages.
On the classic Etch-a-Sketch, it is notably difficult to draw shapes by hand that involve elements any more complex than simple horizontal and vertical lines. That's why we decided to motorize this toy and apply our knowledge of circuitry, software, and mechanics for a curious mix of retro playthings and high-tech embedded microcontroller applications. Not only did we want to slap accurate motors on the Etch-a-Sketch's knobs, but we also sought to implement a tipping mechanism that would completely remove manual manipulation from the handheld toy. It would draw and erase completely autonomously, with accuracy and speed that is otherwise unattainable by hand. The end result met our expectations and revealed many the challenges involved in combining mechanics, electronics, and software in one project.
High Level Design
When we set about brainstorming ideas for an ECE 4760 final project, we wanted to involve a good mix of software, electronics, and mechanics. As we looked to the web for inspiration, we stumbled across a curious project by Angela Yuan: a motorized Etch-a-Sketch that would draw the time once every minute and then erase itself. We immediately found this mix of retro childhood toys and high technology attractive; it had the potential to involve significant mechanics, a fair bit of software, and high-power motor circuitry – just what we were looking for. Angela's project – itself inspired by the work of Scott Ferguson – looked quite polished, and it was apparent that she had access to complex CNC machinery and expensive mechanical components, such as laser cutters and belt drives. These resources were out of our reach and budget, and so we decided that making a comparably-polished motorized Etch-a-Sketch would be both challenging and fun. To differentiate our project from Angela's, we wanted to use a full-sized Etch-a-Sketch (not the "Pocket" version in her project), and add the feature of printing arbitrary messages on the screen through an RS-232-based interface running on a PC. This proved to be a project with many challenges and caveats, but in the end we learned much and were satisfied with our result.
The most significant mathematics involved in our project dealt with drawing lines of arbitrary slopes in an efficient manner on an 8-bit microcontroller which had no floating-point unit. As line-drawing was one of the first applications of computer graphics, it was a well-documented problem with solutions dating back to the early 1960's. The line-drawing algorithm developed Jack Bresenham at IBM in 1962 was used for efficiently computing quantized approximations of lines between two arbitrary points for applications such as linear plotters. In the Lab 4 exercise of ECE 4760, sample code was provided to compute arbitrary line rasterization into a screen buffer. The algorithm used therein was specifically optimized for low-level, limited-computing calculation that involves no multiplication or division, and instead is implemented using only integer arithmetic: addition, subtraction, shifts, and comparisons. For details about this method of optimized line drawing, see the University of North Carolina line-drawing algorithm web page. It works by iterating over the longer dimension of a line between two x-y points to ensure that the slope is always less than one, which in turn enables the use of integer-only operations, allowing the algorithm to be very fast.
As used in our project, the algorithm is modified to progress the horizontal and vertical stepper motors which directly drive the Etch-a-Sketch's respective knobs. The stepper motors we chose to do this job provided for very high accuracy; at 400 steps per revolution, they allowed us to define the Etch-a-Sketch's screen space with a rough resolution of 2000 horizontal increments and 1300 vertical – far more than we expected and, quite frankly, needed. This resolution was also flawed by the Etch-a-Sketch's considerable mechanical backlash – a problem discussed later. By abstracting the function of line drawing to an act of going from the current point on the screen to a desired point by a straight line, we were able to define alphanumeric characters and common punctuations as a set of x-y points. These x-y points mapped to absolute positions on the Etch-a-Sketch's screen, and moving its cursor between them was a matter of updating the desired position in software.
To generate 42 character mappings (10 numbers, 26 capital letters, and 5 punctuations and a space), we wrote scripts in MatLab that allowed us to rapidly produce good-looking characters with accuracy by plotting the points in MatLab figures. For the curved lines of numbers like "8" and letters like "G", we used sinusoidal and elliptical functions to generate coordinates of various arcs. The curves were approximated with points connected by straight lines. The more simple characters, like the number 1, were defined in about 10 points, whereas the complex, curvy characters, like the letter S, had upwards of 72 points. To simplify the drawing of all the characters, their points were defined in x-y coordinates relative to an "anchor point" which was near the bottom left of the letter. This also allowed us to arbitrarily scale the size of the letters by simply multiplying all their coordinates by a set factor and aspect ratio. The MatLab scripts also output the final coordinates automatically in a format understood by the C compiler used in the AVR development tools.
To obtain accurate actuation of the Etch-a-Sketch's knobs and precise tilt angles for erasing the screen, we opted to use stepper motors. Stepper motors progress in a direction by a defined angular increment when given an appropriate sequence of currents to their magnetic coils, known as phases. They also provide considerable torque, which was necessary to overcome the stiffness of the Etch-a-Sketch's knobs and the force required to tip it for erasing the screen. The tradeoff in using stepper motors is their rather sophisticated control. The phases of the stepper motors need to be energized in specific directions (i.e., the directions of the current in the motor's coils) and at specific intervals to provide for clockwise and counter-clockwise turning. This is typically done with a state machine, and usually involves upwards of eight states to progress the motors in either directions. To ease the load off of the microcontroller code, we opted to use dedicated stepper-motor controller IC's for all three motors. These IC's required a minimum of two binary signals – a direction signal for clockwise and counter-clockwise rotation and a clock signal which would progress the motor's position by one step angle with every pulse.
A second tradeoff in using stepper motors is the lack of internal feedback. The microcontroller and driver IC rather dumbly assume that the motors progress appropriately when given the right signals, but have no way of actually confirming that the motor did, in fact, progress in that direction. This became a problem when the Etch-a-Sketch's knobs stiffened up at certain points on the screen and the stepper motors failed to rotate when they could not overcome the sudden increase in opposing torque. The software, however, would not be aware of this unless more circuitry was developed to accurately sense the rotation – a feat that was outside of our budget and time allowance. The first stepper motors we used provided just slightly more torque than the minimum required to turn the Etch-a-Sketch's knobs, and suffered greatly from this skipping problem when they encountered increase opposing force from the toy's imprecision. When we upgraded to stronger stepper motors, the problem was minimized but still occurred occasionally. An alternative solution that we briefly investigated was using servomotors, which have built-in feedback mechanisms that ensure proper rotation. However, the high torques required in this application caused suitable servomotors to be very expensive and large, so stepper motors were chosen in the end and generally worked well.
From these hardware tradeoffs come our high-level software tradeoffs. As described, our software has no feedback loops to determine whether the stepper motors progressed to the determined position. Involving feedback methods would have greatly complicated our code and required much more time, so we sacrificed this functionality in order to keep things simple. As a result, we had to accept the occasional hitch in the motors' actuation brought on by inconsistent load torque. Secondly, we avoided implementing the state machines necessary to manage stepper motors in software in order to maintain simplicity. The tradeoff was using more discrete components, i.e., the L297 stepper drivers, which complicated our circuitry.
Intellectual Property and Standards
The Etch-a-Sketch toy is trademarked by the Ohio Art Company and was patented in 1962 (coincidentally, the same year that Bresenham invented his line-drawing algorithm!) and we respected the company's rights to the product. We did not attempt to reverse-engineer it or intend our use of the Etch-a-Sketch for profit– we simply replaced hands with motors for completely academic purposes. Save for tapping a few holes and removing the white plastic knobs of the device, we did not do any extensive modification.
The only standard to which we complied with in the scope of the project was the RS-232 (Recommended Standard 232) used for serial communication between the microcontroller and the computer. This long-standing standard, again coincidentally established in the 1960's, is defined by the Electronics Industries Association. The details of this standard were largely unseen to us as the designers, as the MEGA644's USART circuitry and the MAX233 level-shifting IC took care of all protocol and voltage level specifications.
The major mechanical components of Electric Etch were the front motor-mounting plate and the tilting chassis. The front motor-mounting plate is to hold two motors that drive the vertical and horizontal knobs; the chassis is to tilt Etch-a-Sketch about its center of mass to erase the screen. For ease of mechanical manipulation, acrylic was chosen to be the basic material of the mechanical structure. Despite its brittle characteristic, acrylic proved to be sturdy enough to hold relatively heavy motors as well as Etch-a-Sketch.
In order to motorize Etch-a-Sketch, two stepper motors were directly coupled to two knobs with vinyl tubes. The motors were mounted on the front acrylic panel, which was bent 90 degrees with a heat gun on the sides to be attached to Each-a-Sketch. On each side of the bent front panel, two plastic bars were bolted, and the distance between them was exactly the thickness of Etch-a-Sketch so that the acrylic front panel can be clamped on to Etch-a-Sketch. Also, in order to be mounted on the tilting chassis, two holes were drilled through the front clamping plastic pieces, and wooden dowels were fixed on the plastic pieces by setscrews.
The tilting chassis was built simply by bolting 3 flat acrylic pieces together in 90 degrees with two plastic corner blocks to form a cornered U shaped stand. Two holes were drilled on the side pieces so that the tilting wooden dowels can be inserted through the chassis and the clamping plastic pieces. In order to keep the wooden dowels in place relative to the two chassis side pieces, bushings with set screws were used. On the left side of Electric Etch, the tilting stepper motor was mounted with a 2-to-1 gear set to reduce the torque required.
The basic circuitry setup incorporates 476 prototype board v.7 on two breadboards. The major electrical aspect with Electric Etch was driving 3 stepper motors concurrently. As explained in High level design section, L297 stepper motor controller chips were used to generate the signals for all three stepper motors. In order to drive the vertical and horizontal unipolar stepper motors, the signals from L297 chips were amplified by ULN2003A Darlington pairs to provide the high current in the order of 1A. Since one Darlington pair is rated for 500mA, it was necessary to connect the multiple Darlington pairs in parallel to provide enough current to the motors. After numerous attempts to drive the motors stably without failing the chips or heating up the motor, 5 Darlington pairs in parallel were connected to each signal of the two stepper motors. Also, it should be noted that these two motors rated for 4V were overdriven at 5V in order to produce higher torque and to uinfy the power supply voltages to all three motors. This overdrive did not seem to cause a problem since we have disabling intervals in between the writing sequences.
For the bipolar tilting motor L297 chip and L298 H-bridge chip were used. In order to cool down the H-bridge, a small copper heat sink was attached to the H-bridge, significantly reducing the temperature of the chip. Also, to prevent the inductive load of the motor causing negative and positive spikes on the supply rails clamping diodes were connected to the H-bridge chip. Since the H-bridge chip is rated at 2~3A, it could provide enough power to the tilting motor, which operates at about 1A and 5V. Although this motor was one of the most powerful one at our disposal, it was not enough to directly drive the tilting axis. As mentioned in Mechanics section, a 2-to-1 gear set was used to drive the tilting motion.
Additionally, in order to implement the interactive functionality, such as a non-volatile message board, the microcontroller was connected to a PC via RS-232.
The software for the Electric Etch consists of several state machines working together. It can operate in two modes: a clock mode, which draws the hour and minute, clears, and repeats every minute, and a message board mode, which simply draws up to 21 characters on the screen for a static message display. A high-level state diagram is shown below:
All the characters are defined as relative points from an anchor point, as discussed in the Background Mathematics section. To progress between points, our code used the line-drawing algorithm described previously. Each character is drawn starting from the bottom left point, which is the character’s anchor. The next point brings the cursor over to the right, and then the cursor begins to draw the character vertically, generally progressing through the points counter-clockwise until the cursor returns back to the starting point of the character. When this happens, the cursor is at the same vertical level as the newly-drawn character’s original anchor position. It then proceeds further to the right, resets the anchor point, and starts drawing a new character if there is one to be drawn. If there are no more characters to be drawn at the time, the cursor goes back to the anchor point of the very first character in the sequence. This is the general method by which the Electric Etch draws capital letters, numbers, spaces, and five punctuations (colon, comma, period, question mark, exclamation mark). All the character points were generated using MatLab scripts. The x-y point arrays for are 16-bit signed integers that are stored in the microcontroller’s program space. Pointers to each available character are contained in a lookup table which contains the character’s address at the index equivalent to its ASCII value. This way, converting a string into a set of points to draw on the Etch-a-Sketch screen using the line-drawing algorithm was done efficiently.
This is the method for drawing strings was used for both modes of operation. In the clock mode, a 1ms time base, generated by the MEGA664’s timer/counter 0, kept track of 1000ms rollovers, at which point it would progress a seconds counter. When the seconds counter rolled over, it would progress a minutes counter, and upon rollover of the minutes counter, the hour counter would progress. If the Electric Etch was in the clock mode, the timer would raise a flag to draw a new time every time the minute counter changed.
When the system first initializes, it defaults to the clock mode and ensures the cursor is sent to a known position by a reset sequence. It first brings the cursor all the way down until it hits the bottom edge of the Etch-a-Sketch screen, and keeps on going downwards until it has sent enough vertical stepper ticks to traverse the entire vertical span of the screen. If the cursor was already near the bottom of the screen when the system initialized, the vertical knob kept spinning downwards, but the cursor simply stayed at the bottom edge due to the Etch-a-Sketch’s slipping. It then moved the cursor back up about halfway up the screen, and repeated this process in the horizontal direction by moving to the left by an amount equivalent to slightly greater than the horizontal span of the entire screen, eventually hitting and stopping at the left wall. It then progresses back to the right a small amount, and assumes this new position as the absolute “zero” position, and also the anchor for the first character. After this happened, the system entered the tilt state, where it actuated the tilting motor to tip the Etch-a-Sketch in order to erase it. It was then ready to start writing strings.
The stepper motors were progressed in a non-blocking fashion, using a multitude of global state variables. The functions responsible for progressing the motors pulsed the motors by one step each time they were called, and operated completely outside of interrupt space. This allowed for the software to attend to other tasks between motor ticks. The motor ticks had to happen with a relatively long time period in between, as the stepper motor drivers and the motors themselves had an upper bound on the frequency of steps. So, between the motor ticks, the software was able to attend to other functions, such as interpreting packets received from the PC over serial and responding appropriately to them. To maintain the concurrency already supported by the stepper control functions, we implemented the serial communication routines in a non-blocking interrupt-driven fashion, borrowing much of the code from our Lab 3 assignment. These and the stepper control functions enabled the nearly the entire code to be non-blocking, able to respond and attend to commands from the user at the PC terminal. When initialized, the Electric Etch greeted the user with the following message via a terminal program running on the PC:
Welcome to the Electric Etch!
Default mode is Clock, and the current time is 0:00
Type 'help' to see all commands.
If the user typed ‘help’, the Electric Etch replied:
Here's a list of possible commands:
'help' - shows this message
'set time hh:mm' - sets the Etch time to hh:mm, where 0<=hh<=23 and 0<=mm<=59.
'message' - sets the Etch to recieve a message of up to 21 characters. The next command sent will be considered the message. Send this command to set a new message.
'clock' - sets the Etch to clock mode. Draws the time every minute.
The next thing a user would typically do is set the 24-hour time by typing, for instance, “set time 18:57”. The user could type ‘message’ followed by a message of up to 21 characters which the Electric Etch would proceed to sketch out on the display, with a maximum of three lines of 7 characters each which wrapped around to the next line. Should the user send a bad command to the microcontroller, it would respond with one of the following error messages:
Sorry, your command was too long. Try again!
Sorry, but that's an unknown command. Type 'help' to see known commands.
Sorry, but that command is not formatted properly. Type 'help' to check command format.
At any point in time, the user could change the mode of the Electric Etch, to which it would respond by resetting the cursor, clearing the screen, and displaying the information appropriate for that mode.
One of the trickiest things that we tried to achieve in software was correcting for the mechanical backlash of the Etch-a-Sketch’s knobs. In the end, we were not able to achieve the level of correction we wanted. This is discussed in more detail below in the Trial and Error section. Difficulties also arose from the very complex code that ended up in the final product. A good chunk of the final code was written after several nights of no sleep, and what resulted was a rat’s nest of state machines and literally dozens of state variables. This made the code very difficult and time consuming to debug.
Trial And Error
The biggest problem we encountered was compensating for what we called the mechanical backlash, which we suspected to be caused by the Etch-a-Sketch's internal pulley systems. When the direction of rotation of the Etch-a-Sketch's knobs changes, the internal pulley systems which move the cursor introduce some slack, and the cursor is reluctant to move with the knob for about the first 20 degrees of the knob's rotation in the new direction. This introduced significant deformations when drawing most character shapes. When drawing a test shape of a diamond, this engagement delay produced noticeable corners that were supposed to be sharp but weren't.
We attempted to compensate for this backlash by having the stepper motors provide some "nudges" whenever they changed directions. Whenever a new point of the shape being drawn was reached, the last direction of travel was compared with the direction towards the next point for each of the horizontal and vertical motors. If the new direction differed from the previous one, a predetermined number of steps was applied in the new direction to overcome the reluctance of the pulleys and get them to engage with full traction in the new direction. The number of these nudge steps differed for the two motors, and was determined by trial-and-error. For the 45° diamond, this method appeared adequate.
However, when we transitioned from drawing simple test with regular angles shapes to the more complex alphanumeric characters, this rudimentary method of backlash correction produced unwelcome results. It seems that the backlash in one dimension was correlated to the travel of the other dimension, and not simply dependent on its individual previous direction. The effect that this had on characters can be seen as slight teeth at the points where servos changed direction.
Though it yielded imperfect letters, this method of backlash did help return the cursor to a consistent position after going about drawing several characters. This was important, since the lack of feedback loop makes the software rest on the assumption that motor steps will always correspond to a constant distance traveled by the cursor on the Etch-a-Sketch screen. With well-tuned backlash correction values, this assumption was very close; without the correction, the absolute position of the shapes drawn on screen drifted due to the offsets introduced after the motors changed directions. If we were to further improve backlash correction, we would have to involve two-dimensional mixing which would take into account the speeds and directions of both stepper motors. This was deemed too difficult to pursue, and so we simply tolerated the small tooth-like deformations of the characters, and welcomed the minimized drift provided by the rudimentary nudging backlash correction.
We also ran into current limitation difficulty. If all three horizontal, vertical, and tilting stepper motors were operated simultaneously, they drew upwards of 3.5 amps of current. At the motor supply voltage of 5V, this equated to nearly 20 watts of power – enough for some laptops, and certainly way too much for a desk clock. Furthermore, the L297 stepper drivers kept the motors energized even when they were not moving, to provide the holding torque which stepper motors are used for in many applications. We took several measures to reduce the current draw. Since the two knob motors did not need to maintain a static holding torque, the software individually disabled the outputs of the stepper drivers by bringing their enable signals low. A similar cut-when-not-in-use approach was applied to the tipping motor, though at the end of every tipping cycle, the tipping motor was held in place for about half a second to prevent the momentum of the tipping assembly from swinging the Etch-a-Sketch to a hard-to-see angle. This proved quite effective. However, these software-based methods of current limiting were still not enough. Firstly, the Darlington arrays which drove the unipolar knob motors had a rating of 500mA per output, and the knob motors, which operated at 1V above their nominal level, drew upwards of 1 amp. When actuated simultaneously, the knob motors alone drew about 2.5 amps. To allow for this, we had to hook up the Darlington arrays in parallel, and since we had sampled 10 of these chips, we decided to spread the load current across five parallel Darlington outputs – that is to say, each of the total 8 phase wires from the knob motors was driven by 5 Darlington outputs in parallel. This also kept the temperature of the Darlington IC's quite low, and still conformed to the output current capabilities of the stepper motor drivers; each driver could nominally source 10mA, and each Darlington input nominally took 0.8mA. Finally, we tried a variety of power sources to provide the 20 watts of 5V power. The bench power supplies found in the ECE 4760 labs could not source this power, and we eventually settled on an old PC ATX supply that was rated for 25 amps on its +5V rail.
Another problem that we did not immediately overcome was the tipping mechanics which were necessary to automatically erase the Etch-a-Sketch screen. Our original idea was to have a single wooden dowel, placed behind the Etch-a-Sketch assembly at its vertical center of gravity, around which it and the directly-coupled knob motors would rotate. What we did not foresee was that the combined weight of the Etch-a-Sketch, the stepper motors, and the retention structure shifted the horizontal center of gravity enough to require a very significant amount of torque on the dowel to rotate the assembly. Two days were spent on figuring out ways to overcome this. We ended up moving the rotating dowel to the front of the Etch-a-Sketch, very near the rotating assembly's two-dimensional center of gravity. At this position, the dowel obstructed the Etch-a-Sketch's screen, and so we cut the middle part of the dowel out and used thick plastic blocks at the links between the dowel ends to compensate for the lack of rigidity. Still, directly driving this dowel with a large stepper motor did not provide enough torque to reliably rotate the Etch-a-Sketch for erasing. Luckily, we were able to borrow a matching set of reduction gears from the T&AM biorobotics lab that doubled the effective torque at the dowel. This adequately and reliably tilted the assembly, and erased the etched image surprisingly well, perhaps due to the intentionally-jittery motion of the tilting motor.
Finally, we originally intended to use a Maxim DS1307 real-time clock IC that we had from a previous project. The chip offered the advantage of being powered by a backup button battery, and would retain system time and date between power cycles. Unfortunately, the only chip we had left seemed to be faulty, and would not communicate with the MEGA644 over its two-wire interface. We ended up implementing a volatile time base on the microcontroller itself.
Due to careful consideration and planning of the non-blocking functions in our software, the user interactions with the Electric Etch performed over a serial terminal on a PC were all very concurrent and lag-free. Save for the response to the ‘help’ command, which transmitted a large chunk of text over serial, the microcontroller’s software operated without any hiccups or latency. Commands were still interpreted and acted upon, even while the stepper motors were in full motion. Longer software testing would have surely revealed bugs, but the basic functionality we aimed for worked consistently.
The biggest accuracy compromises came from the mechanical Etch-a-Sketch device itself. Over time, its backlash characteristics wandered, its knobs would randomly stiffen up, and some points on the screen would exhibit very inconsistent mechanical characteristics. For these reasons, the accuracy of drawing precise characters on the screen was a hit-and-miss affair. Backlash is common to many mechanical devices, but in the case of the Etch-a-Sketch, where no form of feedback was implemented, it proved to be quite a frustration. Otherwise, software kept an accurate time base and the circuitry also proved very reliable.
Since the device is highly mechanical as well as electrical, safety of both aspectes should be ensured. In order to enforce the mechanical safety, all the parts were carefully machined to be bolted together rather than tying or taping them. Also, since the motors require heavy duty powering, electronic chips as well as the motors tend to get rather hot. In order to avoid possible overheating of the components, all the chips were operated below their threshold and a heat sink was implemented to H-bridge of the bipolar tilt motor.
Interference and Accessibility
Most of the work on this project was performed outside of the ECE 476 lab in the labs of our respective project teams, where we had access to better equipment and more space. We therefore did not notice any interference with other people's designs, and since we didn't use any RF circuitry, no interference was expected. In terms of accessibility, our design requires users to be able to use some method of computer text entry, like a keyboard or voice recognition, to communicate to the device through a serial port terminal program running on a PC. Also, as this is a visual device, it is not at all useful for the visually-impaired. These are the only accessibility limitations which we thought of. When designing the terminal interface, we took care to give user-friendly textual descriptions of the functions, and look for and give feedback about input errors without using cryptic codes. For instance, instead of replying "RX Buffer Overflow" when a user types in too long of a command, the software actually says, "Sorry, your command was too long. Try again!" and suggests a comprehensive commands list for other problems. After all, we did design this project for the kids inside all of us!
Analysis of Results
On the whole, we were able to successfully achieve the functions we set out to implement by motorizing the classic Etch-a-Sketch toy. We implemented a working erasing mechanism, and had an imperfect but satisfactory character set which we could draw on the screen. Like we intended, we were able to draw static messages and display minute time on the Electric Etch. In hindsight, we agree that we should have spent more time on the software with clear, well-rested minds. The lack of sleep amplified our frustrations with the Etch-a-Sketch’s mechanical problems, and slowed down the debugging process. In the end, we fear that we might have had some yet-to-be-discovered software bugs that would have reared their heads if we had more time to test.
But, setting time management issues aside, if we were to repeat the ECE 4760 experience with a similar project, we would have certainly implemented some kind of feedback mechanism that would help us better compensate for the Etch-a-Sketch’s mechanical shortcomings. This could be done by using servomotors instead of stepper motors. We were, however, very proud of our stand and assembly, which was fashioned completely out of scrap parts and yet looked very polished – even matching the Etch-a-Sketch’s color scheme!
As stated before, the only notable standard involved in our design was the RS-232 serial protocol used by the microcontroller to communicate with the PC. This common standard was implemented in the hardware of the MEGA644 microcontroller and in the MAX233 level transceiver, removing any efforts to conform to it from us, the designers.
Our software borrowed the line-drawing code from the sample code provided by Bruce Land for Lab 4 of this class, which he credits to David Rodgers, the author of "Procedural Elements of Computer Graphics". While we did not get a hold of this book for verification, we referred to the University of North Carolina's web page on line-drawing algorithms to understand how this particular implementation worked.
We also acknowledge Angela Yuan's Etch-a-Sketch clock project as the source of our inspiration, and the trail of Etch-a-Sketch projects which she references in her documentation. Fortunately, none of these projects had accurate, in-depth information of how they were implemented – not even so much as the chips used for the projects. This left much of the implementation for us to build up from scratch, and so we feel we have not compromised the integrity of our work. Our work, presented on this website, is in the public domain and is in no way proprietary information – that is to say, it is for academic purposes only and is not intended by us, the designers, for anything outside the purposes of this class, including, but not limited to, personal profit, ending world hunger, or weaponry. We feel that we fully align with Cornell's Code of Academic Integrity.
Furthermore, we did not attempt to reverse-engineer any pre-existing designs, and we neither claim invention nor exclusive rights to any of our work. We are not advertising this project for monetary gain. We feel that by acknowledging this, we are avoiding any patent and trademark issues. As this is not necessarily a novel idea in the sense that it has not been done before, it does not readily present itself as a patent opportunity, and we do not aim to pursue any patents.
We are open to publishing opportunities should interested parties make themselves known.
Our device operates in a small confined region without any wide range of motion, projectiles, or signal transmission. As long as the user makes sure to follow the electrical voltage and current requirements and to keep a safe distance from the gear set, our device would not impose any physical or environmental threat to its users and surroundings. As an advanced version of a classic toy, our device would not cause conflicts of interest of any form. Based on our results, we do not claim to have the perfect motorized control of Etch-a-Sketch. There are some less obvious mechanical complications are involved, and we recognize that our design has limitations to address the complications. Because our design does not provide any advantage to any group of people or individuals over others, there is no bribery involved with out project. Since our project was to design an advanced toy, it does not have great effect on the contemporary cutting-edge technology. What is moderately pertinent to our project may be any device that requires the precise motor position control, such as plotter, machining equipments, or printing equipments. We were exercising our technical skills such as soldering and machining only if we were allowed, when we were allowed, and where we were allowed. We acknowledge our mechanical engineer classmates who have given very useful advices for the structure of our device and appreciate their helpful input to our design. Also, we acknowledge our respective labs where we had a great advantage of using the facilities as well as mechanical and electrical components. Our device does not have any limitation for any group of people or individuals except possibly for visually challenged individuals since it is a displaying device. Our device is a passive device, which does not contain or transmit any personal data or impose threat to anyone's property of reputation. While we were designing our device, we were cooperative with our classmates, especially the ones who were also using stepper motors, in order to share information and encourage each others design projects.
As mentioned above in ethical considerations section, our device is a passive, confined, and safe device which does not transmit any signal. Therefore, there are no crucial legal considerations involved in our project.
|Item||Part Number||Vendor||Unit Price||Quantity||Cost|
|Etch-a-Sketch||N/A||Ohio Art Company||$11||1||$11|
|Unipolar stepper motor||Vexta PX243M-01AA||Jameco||$10||2||$20|
|Bipolar stepper motor||Airpax LB82773-M1||Scrap(476 lab)||Borrowed||1||0|
|Stepper motor controller||L297||STMicroelectronics||Sampled||3||0|
|RS232 level shifter||MAX233CPP||Maxim||Sampled||1||0|
|Custom PC board||N/A||N/A||Owned||1||0|
|Gear set||N/A||Scrap(TAM lab)||Borrowed||1||0|
|SOIC carrier||N/A||Scrap(CUAUV lab)||Borrowed||3||0|
|Heat sink||N/A||Scrap(CUAUV lab)||Borrowed||1||0|
|Acrylic and plastic||N/A||Scrap(CUAUV lab)||Borrowed||N/A||0|
|Power supply||ATX power supply||Scrap(CUAUV lab)||Borrowed||1||0|
- Initial software planning
- Software implementation
- Mechanical drafting
- Software debugging
- Initial software planning
- Mechanical drafting and Machining
- Matlab character developing
Other Online Resources
- ECE476 lab 4 sample code
- Line Drawing Algorithm from University of North Carolina
- Angela Yuan's Etch-a-Sketch clock project