Whiteboard Plotter

Hardware

We started by designing the hardware we would need for the project since we expected the fabrication process would take some time. Since we only had access to a limited number of resources, we decided to construct everything out of 4mm acrylic sheets that could be laser cut on campus by Cornell’s Rapid Prototyping Lab. Using the hardware in the video as inspiration, we designed motor mounts and a gondola to hold the marker in SolidWorks. The use of CAD tools made it easy to rapidly iterate on different spacing.

Each motor mount holds a single stepper motor facing the wall in order to keep the motor shaft as close to the drawing surface as possible. The motors we selected are NEMA 17 stepper motors available from Adafruit. Note that stepper motors are required for this application in order to achieve reasonable accuracy. The pulleys are made of small acrylic blocks that are cut and glued in corresponding slots to make a 3D object. The motor mounts are symmetric, allowing us to use the same parts to construct either side.

The gondola, shown below, consists of two ball bearings that allow the two strings that hold up the gondola to rotate independently of each other. This is required since the angle between them varies as the position of the gondola changes on the drawing surface. A large balancing plate is used to prevent the entire assembly from rotating with respect to the whiteboard. A single micro servo, also from Adafruit, is used to push the entire gondola away from the whiteboard surface, allowing us to draw unconnected shapes.

The complete CAD files and drawings are available here.

Software

A main goal of the project was to explore the advantages of using a Raspberry Pi in applications that traditionally require a microcontroller for real-time guarantees. We thought our project would be a great fit for the Raspberry Pi 2 Model B as our project doesn’t have extreme real-time requirements and it would allow us to focus on developing the code in Python instead of a lower level language. Since Python is generally a much more productive language, this was extremely beneficial as it allowed us to experiment with different algorithms quickly.

The basic principle of our project involved converting x, y coordinates to lengths of the strings holding the gondola. The only things we input to our code is the distance between the two motors, and the starting distances of each of strings. We use that initial location as the origin (0, 0) point. The first step is to calculate the position of each of the motors relative to the origin. To do this we used GOOD OLD Law of Cosines. For those of you who need a refresher, the law of cosines can be used to calculate the angles of a triangle given the length of the three sides:

Using the standard math library provided by python we were able to calculate the angles A and B (shown below) and in turn were able to calculate the x and y coordinates of the motors using basic trig functions.

After obtaining these points, calculating the lengths of the strings given a point is trivial: we use the distance formula from the point to each motor. The harder part of the algorithm was calculate the linear interpolation between the points. To do this, we calculate the number of ticks each motor needs to perform given its current position and a desired position. We then use the ratio between the number of ticks each motor needs to perform to move each at an appropriate time. The code that performs this is shown below:

In the code, we perform a fixed number of iterations based on the maximum number of ticks that must be performed. Within each iteration, we check if each motor should move during this iteration and perform the necessary operation. This algorithm creates a decent linear interpolation because the distance per tick was very small so the resulting line looks smooth. To further improve it, we break up each line segment into smaller 10 mm segments. During testing, this implementation created an even smoother linear interpolation as each single line segment is relatively small, which helped avoid drawing slightly curved lines.

With our algorithm completed, our next step was to be able to generate a list of shapes to draw. We decided to support the well-established G-code programming language which is commonly used to control CNC machines. Thanks to the format’s popularity, many libraries have already been developed by the hobbyist 3D-printing and laser-cutting community that enable conversion of images to G-code commands. We used the svgmill library to convert SVG images into G-code commands that ca interpreted by our control software. Since our software only handles linear interpolation, complex shapes like circles and curves are decomposed into many smaller line segments by the library. The G-code output is written to a file and read in by plotter.py during execution.

Simulator

Before we had all the hardware built, we wanted to start testing our drawing algorithm. To enable this, we wrote a simulator using Pygame to model the physical hardware. The simulator, shown below, calculates the intersection of two circles, which represents the simulated position of the gondola. The radius of each circle represents the length of each string. Thus, individual steps of a motor simply change the radius of the corresponding circle.

In order to make our controller code interoperable with both the simulator and the physical implementation, we take advantage of a RPC (remote procedure call) library that allows us to execute functions across the network. When testing with the simulator, our tick() function simply changes the radius of a circle in Pygame, but when using the real implementation, the tick() function would cause the stepper motor driver to send a real pulse. By using the RPC interface, our code remains identical apart from a single command line flag that sets the remote RPC server.

Stepper Motor Driver

With the simulator and algorithm working along with the completed hardware, we then attempted to control the stepper motors from Python. To do this, we use Adafruit’s stepper motor library, provided with the stepper motor HAT. This library exposes a simple interface to control up to two stepper motors. We also hooked up the pen control servo to pin 22 and used software PWM to control the pen’s position. With this completed, we could begin testing the entire implementation.

Bill of Materials

The following list consists of all the parts required for the project excluding the Raspberry Pi 2.