Difference between revisions of "Robotic Arm 2.0"
(added pict of arm)
(→Updates from Meetings: Friday 12/12)
|Line 40:||Line 40:|
==Updates from Meetings==
==Updates from Meetings==
Revision as of 03:57, 13 December 2008
- 1 Overview
- 2 Current Status
- 3 Updates from Meetings
For our final project we will be improving the hardware and controls for the robotic arm.
- Add in vertical support for the arm in the form of something that can slide/roll over the paper so the arm does not sag so much that the pen cannot be lifted far enough off the paper.
- Make the arm less wiggly
- Improve fasteners
- Increased rigidity in "elbow" joint, using a bracket
- Better coding style for increased readability of the code
- Integrate the two programs
- If possible add functionality for increased user-friendliness editing capabilities
Proposed Time Line
- Allow the user to draw lines and free paths--Sunday 11/23
- Add saving and opening of files containing lines and free paths--Tuesday 11/25
- Write in code to allow the arm to draw what the user has designed--Friday 11/28 (will not be tested until we are back)
- Add the ability to draw rectangles and other regular polygons--Saturday 11/29
- Improve the rigidity of the arm using a bracket at the elbow and tighten all the joints--Sunday 11/30
- Add in a brace that will allow the pen to be lifted clear of the paper--Monday 12/1
- Test and debug code to allow the arm draw what the user has designed--Tuesday 12/2
- Include curve drawing to the GUI and to paper--Friday 12/5
- Implement circles and arcs as well--Sunday 12/7
- Final testing--Monday 12/8
Currently the arm has a solenoid to allow the pen to be lifted, as well as a brace that slides across the paper to reduce the vertical give in the arm so that the pen can be lifted completely off of the paper. A bracket has been added to the elbow joint, and the servo mounting brackets are doubled to increase their rigidity. The pen mounting has been modified to allow a whole pen to be used, instead of just a portion of a pen. The entire contraption is mounted to a 2'x2' piece of plywood.
For the project we are using Processing, an open-source JAVA-based language designed specifically with graphics in mind. Currently our code allows the user to draw line paths, curve paths, and free lines, as well as store and retrieve them from files. SVG path data can also be imported. There is an arm that follows the cursor around the screen and can also traverse previously drawn paths. There is a status bar at the bottom which displays the cursor coordinates, the number of objects, and a message containing brief instructions for the user. Serial commands can be sent to the servo controller and these commands are displayed in a separate info box.
Updates from Meetings
This wasn't really a meeting since only one party (Ames) was present... I (Ames) went to hicks after a math final and played with the arm a bit. I traced, umong other things, the Swarthmore logo. This took about half and hour. I made a time lapse video of the process, which I later posted to vimeo.
Today we went to the machine shop and acquired a piece of plywood on which we then mounted our arm (in order to reduce set-up time tomorrow). We also had a holder for a pen machined so that we can mount a (still whole) pen to the solenoid. We then mounted the arm to the plywood, attached the new pen holder, and tested our arm to make sure that everything would go smoothly tomorrow. We discovered that our code needed to be modified slightly to make the pen respond properly, as we had introduced a bug earlier, so once we had fixed that we tested our code.
We started by finishing curve implementation, so that now the user can draw curves in a semi-intuitive fashion. Additionally, the arm can trace these curves at an even rate and our file opening/saving code can handle curves. Next we reviewed earlier code for parsing SVG path data and moved the code into our program. Now the user can open SVG files, which will be imported as lines and curves. After this we added a mode for moving and resizing the arm on the screen. Then we improved the limit-checking code and added code to allow the user to toggle limiting.
Today we added in the brace and taped all the wires so that they would not get caught. We decided to double up the servo mounting brackets as they seemed to be too thin. In an attempt to fix the bug in the code we changed slightly how the commands to raise and lower the pen are sent to the controller and we made sure that the program closed the serial when the program was exited. Finally, we started to implement curves, which can now be drawn but not traversed or stored in/read from files.
Today we meet in Hicks to work on the hardware for the arm. We reconfigured the elbow joint to use a bracket and we discussed the design of the brace. Once we had determined the specifications for the brace we submitted a request to have the part machined. On the software side we added the solenoid controller to the code, so that the pen is only in the down position when it is actually drawing a line. Unfortunately, we also determined that sometimes when we start sending to the serial our code crashes for an unknown reason. We wonder whether it is an error in the Processing Serial library.
We added code to allow the program to send serial signals to the servo controller, and then a small information box that displays the device and the command to be sent. We decided to store our messages in a HashMap, making it much easier to modify the Strings. In addition, we added interpolation so the arm can smoothly transition in and out of trace mode and between paths.
We squished a few little code-bugs and then added a status bar at the bottom of the screen. We also added the ability to re-trace previously drawn lines using the virtual arm.
We added code to allow the user to draw more than one line path and to draw in "free line" mode. We also added some file I/O and made the robotic arm display and follow the cursor around the screen.
Today we started in a fresh file (we will be adding in functionality from the two previous files). We decided to store our data as a linked list per object, and wrote in code that allows us to do so. We then added in the ability to draw a line path to the screen (however right now only one line path can be drawn).
At the Start
Before the official start of the project we created two programs where we tested out the ideas we were thinking of implementing, not spending too much time on organization. The first of these programs allows the user to draw free lines and then ask the arm to trace on paper what has been drawn. SVG files of only short lines can be imported. The second of these allows the user to draw straight lines, circles, polygons, rectangles, and line paths to the screen. On the hardware side, our arm has a pen attached to a solenoid at the end, however this does not lift the pen up far enough to hold it clear of the paper--additional support for the arm is needed. Also, there is more wiggle in the arm that we would like.