Robotic Whiteboard | Boarderline

Haven’t you always wanted to wake up to the sounds of stepper motors that are writing the day’s weather for you on a whiteboard? Well, now you can(!) because the robotic whiteboard is alive and functional! It took sweat, tears, ABS plastic prints, and C++ classes, but now it is ready for action! (-ish, will be explained soon). This robot can write any text string that’s being inputted to it and also write real-time and current weather.

Now that you know what the robot does, and (maybe) took a peak at the video, let’s dive into the process I went through to make this robot.

At the very beginning, I designed the mechanical parts. Starting with a sketch on paper, that got later 3D modeled using Autodesk Fusion 360, I planned on printing out the mechanism and using an 80/20 aluminum beam for the arm itself. Since I wanted to move the arm using stepper motors, this should have been a huge glowing red light for me. Aluminum is HEAVY, well not really, but it is too heavy for stepper motors who’s torque is not strong enough. 

Big Gear Aluminum Demo

The steppers were only able to move the rod linearly, no change of angle was possible.

Only after a friend told me about the unprecedented option of changing the material of the rod to a lighter alternative (thanks friend, you really did save the project), I decided to re-model the whole mechanism (for the third time), and actually print out the rod as well. Adding the lighter mechanism to a sturdy aluminum frame I’ve built allowed the thing to work for the first time!

Sitting on the floor in my dorm’s lounge, I was really really excited to see the robot moving, I was like a proud parent 🙂

Printed Rack

3D printed machanism working

Anyway, enough of that. Now that the robot was mostly assembled (the servo motor would be added a little later), it was time to start coding. This was the second big chink of work I had to do. To get everything to work, I went though the following process to develop the program:

1. Goal: Navigate to specific coordinate

Challenge: Deciding how to divide the board into cartesian(X and Y) coordinates, that would later be represented by polar coordinates (radius and angle).

2. Goal: Navigating between two coordinates

Challenge: After I managed to get to a specific coordinate, moving between two of them was fairly straightforward. Though despite moving between the locations successfully, the robot moved in inconsistent paths. Usually the angle movement was a lot faster than the radius movement. To correct that, I tried the next goal:

3. Goal: Navigating in a straight line between two coordinates

Challenge: The math behind the process was a little tricky. The way I chose to approach this was to calculate a line equation, sample it in preset intervals (generate waypoints), and move in between the coordinates of those points. Since the points are now very close to each other, the effects of uneven paths are negligible.

4. Goal: Write text characters on the board.

Challenge: After initially hard coding the letters of the word ‘MIT’ to the Arduino C++ sketch, I decided that I needed a more flexible solution. Therefore, I chose to code the path needed to write each text character with respect to a general coordinate. That means that if I decide to move that coordinate, the whole character will move along with it. To facilitate the writing of consecutive characters, I divided the board’s workspace into bins that could each hold one letter.Owing to that setup, I could eventually ask for the letter ‘A’ in index 27 for instance, and it will be written there.

5. Goal: Write Strings of characters

Challenge: At this point, most of the hard work was done (yay!). A quick for loop looked through a given string (with a start bin index number), and placed the characters into the corresponding, consecutive, bins. This method ensures that long words will overflow to the next line.

6. Goal: Adding real-time and weather

Challenge: Like I wrote at the very beginning of the post, I initially wanted the board to be able to write the weather and time. To do that, I made the ESP32 communicate with some APIs and get the information from the internet. Since I took the class 6.08 last semester (Intro to EECS with Interconnected Embedded Systems), I didn’t struggle too much with this step.

One of my main goals, coding wise, were to make it very easy to interface with the board once everything was done. Therefore, I decided to wrap all the related functions in a class. On paper, that means that the ESP32’s code could now create a few instances of that class and control multiple Boarderlines at once! Would I ever do that? Probably no. But it’s still a cool thing to have in mind 🙂 .

This Boardeline class turned out to be super convenient, to the point where the ‘loop’ code looked like this:

void loop() {

  board.printString("I CAN ", 10);

  board.printString("BUILD", 18);

  board.printString("LETTERS", 25);

}

The number by the Strings represent the indices at which its first letters will be written. Like stated earlier, if there would not be enough room on the board, any long word will overflow to the next line.

Boarderline Input Matrix

Boarderline Input Matrix_2

The bins layout for characters

Like one of my other project Javeliner, this project is was also funded by MIT’s ProjX and presented in ProjXpo, which was a cool maker-fair-style even they hosted where all the funded participants showcased their work. It can be seen in the video, and was overall a very fun time.

Even though I’m happy with the way this robot works, I want to make it even better by adding some more features. Primarily, I want to add closed-loop control to this project. That means adding a potentiometer that would read the angle and maybe another linear linear potentiometer to read the radius. Since now the robotic arm almost “guesses” where it is, those sensors would be very helpful to actually get the positioning information. That addition would hopefully eliminate the drifting problem I encountered, where the robot writes a string well, but shifts it all half a centimeter to the left on a second run (until it will eventually get to its physical stop).

The second thing I want to add, is the ability to draw and maybe read G-code. Once the accuracy of the robot improves (hopefully using the potentiometers), I hope that this feature will be somewhat simple (though realistically I know it’s not going to be  🙂 ).

Unfortunately, those improvements will have to wait a bit, since the board is now stored in a closet in Cambridge, and will stay there for the next three months. Hopefully it will not fall down and break while I’m gone 🙂

Storage Time

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

w

Connecting to %s