This is Mechpen, my newest drawbot.
The idea was to have a robot arm that could sketch on a rather large surface.

It is a SCARA (Selective Compliance Assembly Robot Arm) robot arm, meaning the robot has a shoulder and an elbow joint and a hand. Mechpen has a reach of 140 cm which means it could sketch up to A0 format.

Hardware

Most self-built SCARA robots you find online are used for 3D-printing and have a rather limited range but good accuracy. Mechpen in contrast was designed to have a long range while still have ok-ish precision. So the arm and everything that reaches out from the base should be as light weight as possible. It don’t has to carry more than a pen. Both motors and all the electronics have to sit in the base structure. The base structure can and should be heavy, so it doesn’t tip over if the arm is fully extended. All in all Mechpen weighs around 15 kg.

I bought the pulleys, bearings, belts and that kind of stuff. The rest of the hardware was custom machined. I even drilled a lots of holes in almost every part of the arm to save some weight.

Each part of the arm has a length of around 700 mm and is built from 6 mm carbon tubes. Each tube is slightly angled inwards in the forward direction. This alone was not enough, the upper arm twisted quite a bit when the forearm was at 90°, so I added two more diagonal tubes to the upper arm. That helped a lot, but even that did not solve the problem completely. More on that later.

The motors have a 0.9° step, which means 400 steps for a full circle. Each motor is geared down with belts by factor 5. With the drivers set to 1/32th stepping that makes 177.778 steps per degree.

Initially I wanted to have the possibility to rotate the hand with attached tools or pens. That plan was dropped because too complicated (and not needed for pens). The easier version was a servo that could lift the pen. As I wanted to lift the pen more than just a few mm, I designed a linear rail and a wheel that is attached to the servo. Then there is a nylon wire attached to both ends of the rail and with a 180° servo I could get a travel of around 70mm max.
At the bottom end of the rail I attached a small piece of Delrin in which I inserted two small magnets. For the pen I machined a spring loaded mechanism, which also has two small magnets and snaps perfectly into place when it comes close to the rail. This way I can swap out pens easily or even replace it with a sensor.

Some of the machining can be seen in the Making of.

Electronics

Mechpen’s brain consists of a Einsy RAMBo board and a Raspberry Pi. The Einsy RAMBo is a board designed for 3d printers, e.g. it runs in the latest and very successful Prusa MK3 printer. It uses TMC2130 driver chips from Trinamic to control two NEMA 23 stepper motors (0.9°). These chips have a couple of smart features that make them almost silent and very current efficient.
The Raspi runs a high level printer management software, named Octoprint, that talks to the Einsy RAMBo via USB-cable. Both boards are powered by a 12V 35W notebook power supply.

To make the pen lifting mechanism as light as possible I thought of a bowden wire, driven by another stepper motor, that sits in the base structure. This turned out to get more and more complicated. Therefore I looked for a small and light servo with much travel as possible. I found the TGY-180D from Hobbyking, which is one of the very rare small 180° servos. It’s cheap, a bit noisy but works quite ok until now.

After the first tests I found out that the elbow still flexes too much to get good results. The hand was about 20 to 25 mm lower if the elbow was at a 90° angle. That could not be covered even if the pen was spring loaded. The drawings were distorted in one place and the pen wouldn’t even touch the paper in other places.
OK, then use software to fix a hardware problem (most of the times a bad idea)! First I measured the difference in all angles and it looked as if I could get away with a sin function, depending on the angle between upper arm and forearm. Unfortunately that didn’t really work out.
That next idea was to use, what is known to 3d printers as bed levelling. I bought a VL6180X distance sensor and attached it to the lifting mechanism. With that I could scan over the whole plotting area and record the height at multiple points and build a grid of height values. Using this information I could adjust the height accordingly, while plotting. Bonus is that plotting even works if the ground is a bit uneven. The accuracy in height is good enough for my purpose so it looks like I get away with it this time.

Software

On the RAMbo board runs a tweaked version of Marlin, a firmware for 3d printers. The firmware accepts G-code as a way to control the printer. Marlin supports a variety of different 3d printer configuration but unfortunately the support for SCARA kind of robot arms is broken right now. A couple of forks exist but nothing was working for me. Also, if you’ve looked into the Marlin source once, it’s quite gigantic and takes a while to get familiar with.
I wrote a small SCARA simulation in processing to get the forward and inverse kinematics right. After I got that working, I tweaked my Marlin version and implemented the missing parts. It took a while but finally the robot behaved. Currently Mechpen only draws in the first quadrant, so from 0° to 90°. This could be extended to make it draw also on the fourth quadrant, to -90°. I left that out right now because it non-trivial to implement and optimize.

I added additional G-code commands to control the servo to lift the pen. Marlin had already servo support integrated but without any easing, so the arm was heavily shaking up and down after a pen up or pen down command. I replaced the servo lib with Todbot’s ServoEaser, which works much better.
To support the bed levelling I added another gcode command to trigger the recording. It moves the sensor to all positions of a grid and takes several measurements and saves the average. After it’s done with all points we can save the data to EPROM to have it available, even after a reboot.

On the Raspi runs Octopi, a preconfigured version of Octoprint. This great piece of software (all open source!) is normally used to control and manage your 3d printer over the local network, without the need to have your main computer attached to the printer while printing. And because of that I can upload my gcode files via WIFI to Octoprint on the Raspi and then use the web UI to start or stop a plot job. I can even flash the Marlin firmware over WIFI. Nice!
No customizations on this part.

To convert line graphics (SVG) to G-code I wrote another tool in processing, also named Mechpen. With it I can load SVG files, scale them and move them to correct position for the plot, to be sure everything fits on the paper. Additionally I can select how every path is plotted (hide, stroke, hatch-fill, stroke and hatch-fill). This enables me to do multi color plots. I load the SVG, enable all paths for one color, export it to gcode, then do the next paths of the other color and export it again. So I end up with a two or more gcode files. Then all gets uploaded and the first plot is started. After it is finished, I can change the pen for another color and start the next gcode file.

To get input for the plot we have different options.

To plot a picture, I usually select a photo and the use inkscape to convert it to vectors. It helps to reduce colors to 3, max 4 colors or grays. Then this SVG can be used in Mechpen to create paths with different hatch fills, depending on the color or gray value.

To plot a drawing, e.g. a patent drawing, I load the bitmap in inkscape and select “centerline trace”. That’s an extension, here on github.

Another great option is to look for nice plots on Turtletoy. Turtletoy lets you explore turtle graphics with only a couple lines of javascript, e.g. the plot above is called Cubic cityscape. Every turtle can be exported as SVG.

A further option is to do some coding in Processing. Doing line graphics and exporting it to SVG is extremely easy in Processing. Two examples are included in my Github repo .

For inspiration, follow #plottertwitter on twitter.
A nice collection of tools, resources etc. can be found on drawingbots.net.

Wrap-up

This project took a while to complete, almost 16 months of my spare time, on and off.

The accuracy is within a couple of millimeters, if all belts and set screws on the pulleys are tight. There is a certain wiggling that can be seen on the plot. It’s stronger in certain areas, depending on the speed and also the angles the arms are at. In other areas it’s a clear straight line. However, for me that adds to the character of Mechpen ;)
Of course you can build robots that are more accurate, but only with stiffer and sturdier materials, which means more overall mass, which means bigger motors, which means even more overall mass.

With this machine, the finished drawing is nice, but it’s quite more interesting to see how the plot develops. It’s a bit like campfire. I like that.

Thanks to JumJum for letting me use his Tuna and the Robot!
Thanks to Jan for letting me use his Greta design!

Links

• Github repo Source and design files
• My Marlin firmware fork
• More hires images




• Einsy Rambo
• TGY-180D servo with 180° travel
• VL6180X distance sensor from Pololu
• NEMA 23 Stepper motors from Stepper Online




• Marlin, 3d printer firmware
• Octoprint
• Todbot’s ServerEaser
• inkscape extension: centerline trace
• Turtletoy, turtle graphics with Javascript
• Processing
• SCARA robot arm
• drawingbots.net

Here comes the 14th and final part of a mini series in which I paint the water line, add minor bits and pieces and put it in the water.

My projects are getting larger and larger lately. This time I’m trying to build a boat. A small wooden boat of 15 feet. I thought building a boat that you could actually use, that should be great fun. And of course much more fun than to just go and buy one.
So I scanned the web for designs that looked relatively easy, even for first time builders. I settled with a boat, called Fleet, designed by Ross Lillistone. It’s an elegant, slim and clean boat. I ordered the plan and then started to build a model first. They say you should build a model first to get an impression how things fit together, so I did that.

The method to build this boat is called “stitch and glue”. That means you cut plywood pieces according to the plan, which then get stitched together with cable ties. So the cut plywood panels define the shape of the boat. This is much simpler and faster than the traditional method where you build the boat upside down on frames. After stitching, you glue the pieces together with epoxy and cover the seams with fiberglas.

After the model was complete, I started the real thing. The idea was to prepare all pieces in my small workshop and then move out to a bigger place to assemble all parts. I bought 6 plywood panels, 4 x Hydro AW100, 6mm, 250x153cm and 2 x Okoume AW100, 250x122cm, which makes in total 21.40m². The video above shows the first part of the preparation.

Here are more parts:

This project has been on my to-do list like forever. Over the last years I acquired a couple of tools and now I have a somewhat decent workshop. The Raspi 3 is there and quite powerful enough to run MAME. I even saved an old TV from the dumpster and had it sitting on the shelves for ages. So it was like now or never.

Motivation

I have a soft spot for 8-bit arcades. When I was a kid, maybe 13 or 14 (around 1980!), I was on a vacation with a good friend of the family. He was a truck driver and drove always from Germany to Italy and back. A trip usually took 4 to 5 days. So I was on a truck for a week, which felt really cool. We delivered some stuff to Bologna and a couple of more places. Then we drove back to Milan and we had to load arcade machines. I saw these for the first time. At least it felt like that. All machines where running. All coin doors were open! Somebody saw me standing in front of them with huge eyes and showed me how to trigger the switch to get credits for free. BAM! I was hooked.
I played Galaxian for 2 hours straight. As the truck was loaded and we had to leave, they had to peel me of the arcades!
The next couple of years I dumped a lot of coins (Deutsche Mark) into arcade machines and I got quite good at Galaga, BombJack and Gauntlet.

Then, ages later, I stumbled upon MAME, the Multi Arcade Machine Emulator and had fun digging up the old games. I even built a controller box to be able to play at least with proper joystick and buttons.

Then, 4 months ago I decided, that I should have all tools together, that are required to build a complete arcade cabinet. The required skills I would learn by doing, hopefully.

The Plan

Galaga was always one of my top-5 most loved arcade games. I searched around for inspiration and maybe plans I could use. I found a quite promising one here and also dug up the artworks as SVGs. Looking at the plans and at the very steep stairs to my workshop in the basement, I decided to scale everything down to 4/5th of the original size. Smaller and lighter, easier to handle.

Tools and Parts

I had to buy a special slot cutter to cut the slot for the T-molding into the two side panels.

• Router, with station if possible
• Slot Cutter
• Jigsaw. Tablesaw is nice but not a must.
• Cordless drill

Parts listed here were used to build especially this cabinet. The Grundig TV set was used, because I had it sitting on the shelves for years and it fit the 4/5 down scaling nicely.

• ca. 3.5 m² of 12mm birch plywood (aka. Multiplex)
• ca. 8 m of black, 1/2 inch T-Molding
• Joystick and arcade buttons
• Coin door and coin acceptor
• An old TV set: Grundig P 37
• Glas plate (safety glass or ESG, Einscheibensicherheitsglas in german) as cover for the TV
• Cabinet art, printed on vinyl, done by CKS-Megaprint

Electronics:

• Raspberry Pi 3
• ControlBlock, a control cape for the Raspi to easily install joystick and buttons.
• Class D amplifier from Adafruit
• AV cable with 3.5mm jack
• Power supply for the Raspberry Pi, the more amps, the better
• Another power supply for the amplifier, 9V, 500ma
• LED strip, like this one.

All in all, it costs around 400 €, maybe less, depending how much of the parts you have already. Definitely not cheap, but for me absolutely worth it.

Building it

Here are two videos to show a bit of the work that went into the cabinet. These are not explicit how-to videos, they are not detailed enough for that. Still, you might get a hint on how to work on bits and pieces.

I decided to glue all pieces together, except the back of the cabinet. I would use screws to mount it. That works quite well until now.

While putting everything together, I noted that my TV didn’t stay on, if I kill the power and turn it back on again. It would go into stand-by. That was not an option because I wanted to have a main power switch that would turn off everything. That was solved with an IR-LED and an old Arduino diecimila, that was lying around. I dug up the right IR codes for my TV and programmed the Arduino with a modified version of IRDB’s code and used it as a kind of automated IR remote control.
After turning on the main power, the Arduino waits 5 seconds and sends the turn on code. Then, after another 5 seconds, it sends the channel down code, to switch the TV into AV mode. Works like a charm :)

Wiring up the ControlBlock was quite easy. Everything is well documented. One feature is extremely useful when using a Raspberry Pi. You can connect power to the ControlBlock and then have a switch, that controls the power for the Raspi. But instead of simply cutting off power while running and risking a corrupted file system, it initiates a proper “shut down” and powers off after that. So now I have two switches for my cabinet. To power it on, I switch the big green one on, that’s the main power switch. Then turn on the small red one, it provides power to the Raspi. To switch the cabinet off, simply reverse the order. First turn off the red one. It will shut down the Raspi. When the screen goes black completely, it is save to kill power with the green switch.

Software

I used RetroPie 3.6 for my build. The installation went quite easy. I just downloaded pre-build images of the distribution and write that onto your SD-card.
Next I installed the ControlBlock, following these instructions. After the joystick and the buttons were working, I further configured RetroPie through its settings. There you could disable all unwanted emulators, making all the menus a bit cleaner. To transfer and backup configuration and ROMs, I used an USB-stick. That felt like the easiest way, even if the Raspi has Wifi on-board.

As the TV has to go in portrait mode into the cabinet, at least for Galaga, the display has to be rotated by 90°. There is one option to do that for the whole Raspi. I tried that and it worked fine, but unfortunately that resulted in bad performance in some games as the sound was really choppy. It got better, if I let the Raspi in normal orientation and made the rotation in Mame4all. That is the reason, why you see the boot up and game selection in wrong orientation but the game runs correct.

Of course, all this configuration and installation was done before installing everything in the cabinet!

Trivia

There is a “no fire” cheat for Galaga. Actually, it’s not a cheat, it’s a bug. And if you wonder how it came to be, there is this fantastic detective story, Galaga No Fire Cheat by Chris Cantrell. A wonderful read if you love programming, reverse engineering and debugging.

And here is another gem, an interview with Yokoyama, one of the Galaga developers. This gives some very interesting insights in game development back then.

Wrap-up

This was a fun build for me. If you drop a coin into the slot and the machine responds with the “one-credit-salute”, it’s like a time machine. Even while building and testing things out, I caught myself playing for a while. Even today these arcade games are attractive to many. They are easy to learn, difficult to master, a key ingredient for a compelling game.
I invited a couple of friends to celebrate the completion of the cab and we had great fun with a Galaga challenge and some beers. It performed flawless until the socket of joystick came loose, but that was easy to fix.

pew pew pew!

Links

• More images at flickr
• My plan, scaled down to 4/5th, galaga-dxf.zip
• My plan, as PDF, galaga_plan.pdf
• Galaga at KLOV
• Original plans, full size, mspacman_eps.zip
• MAME, the Multi Arcade Machine Emulator
• RetroPie, the emulator distribution for Raspi
• ControlBlock, the control cape for the Raspi
• My first MAME controller: Tupperware Arcade Controls

Four years ago I built The Almost Useless Machine, a tiny machine that tries to cut a wooden dowel. Here comes the second incarnation, a bit stronger and a bit more robust.

There are quite some videos of home made power hacksaws out there. I think I watched all of them. I thought, I could build something similar. So I started designing, ordering parts and materials.

Parts

The motor is a wiper motor, I guess. It runs up to 17 Volts and has quite some torque. Unfortunately I found out later that it gets really hot after a while.
The power supply is a adjustable 65 watts notebook power supply.
All other parts, excepts bearings, nuts and bolts, are machined out of aluminum.

Electronics

To control the motor I designed a simple PCB with a small 8-bit AVR (ATtiny25) as brain. The controller reads a pot and puts out a PWM signal to drive a MOSFET, which in turn, drives the motor. I added a microswitch as endstop to the arm, so that the motor stops when the work is done.
PCB was made at OSHpark. It has only through hole parts, space was not an issue for this project. Very easy to solder.
A controller is not really required by the project but it adds some nice features like a soft start of the motor.

Making of

Here is a bit of how the whole thing was machined and how it’s put together. All in all it took almost 5 months of spare time.

Wrap-up

As usual, I learned a couple of things. And I screwed a couple of things. Several parts have been done two or even three times, before I got them right. One of the ways I fail often, goes like this: I already invested quite some time into a piece and now I have to do an “easy” job, like drilling two aligned holes. Then I think “Hey, that’s easy, I won’t use the drill press, I’ll do that by hand!”. Then the holes aren’t perfectly aligned and you are able to see it, even from the distance.

Dang! Try to remember that!

Still, I think it came out nice and I like the way how it’s slowly chewing through the aluminum.

Links

• Plans and PCB at githup
• More images at flickr.
• Excellent home made power hacksaw by myfordboy.

Last November I was part of a web documentary by arte.tv about makers and FabLabs and the like. It consists of 8 parts and deals with a couple of different aspects of the maker scene. Great work, thanks Adrien and team!

From time to time I enjoy simple and quick projects. It’s like taking a break from that other long running project. This simple stool took me around 4 hours to make. Best of all, it’ll never need to re-charge.

Searching for simple stools to make I stumbled upon the DIY Furniture Design Bank from Dick Reynolds. That is a great collection of simple furniture, not only stools. Almost all designs should be fairly easy to build. Perfect for me, as I have no real knowledge on how to build furniture.

I cut 18mm thick baltic birch plywood into 60mm wide stripes (I adapted the design slightly to have nicer metric sizes).

All parts got a light sanding and the edges were trimmed with a small router. Then I started gluing parts together, using wood glue.

I used my small router and a homemade compass to cut the top out of a melemin board (Siebdruckplatte in german). It was then screwed to the structure using big fat furniture screws (aka IKEA screws). Then I gave it a light coating of varnish.

The finished stool is really sturdy and looks quite good. I guess I’ll build a couple more as in-between-projects.

Links

• Sketchup
• DIY Furniture Design Bank

Thinking up robots and machines is one of my number one pleasures. Being able to realize them, tops everything. I added a couple of power tools to my small shop and as a result, my projects got bigger and more mechanical.
Here is my latest creature, the Paint Machine. It’s a machine the prints simple bitmaps with spray chalk on the street or sidewalk.

Some of the key features:

• dimension: width: 220cm, length: 38cm, height: 24cm, weight: 12kg
• printing speed: ca. 0.036 km/h
• resolution (4:3): 61px * 46px, print: 225cm * 170cm
• swappable print head
• remote controlled with smartphone app

I started working on this in April and built almost everything from scratch. A lot of time went in designing parts, trying them out and then re-designing them. Now I guess, it would require a lot less time to build a second one.

Needed parts and materials

Here is a list of parts that I used to build it. I’ve probably forgotten some but I think the most important ones are included. Cost for everything is around 600€ but you could definitely save a lot by using used parts or adapt to what you have already laying around.

Motors, wheels and pulleys:

• 4 inline skate wheels with bearings and spacers
• 3 Pololu 50:1 Metal gearmotor
• 4 HTD pulleys, 26 teeth
• 2 HTD pulleys, 14 teeth
• 1 HTD pulley, 18 teeth
• 2 HTD toothed belts, 160 teeth
• HTD toothed belt, 2m

Rails:

• 5 1m V-slot 2020
• 4 OpenBuilds Solid V Wheel Kits and 2 eccentric spacers
• various OpenBuilds M5 screws, T-nuts and joining strip plates
• 2 micro switches

Main body:

• 18mm birch plywood, laminated, 200cm * 40cm and 80cm * 40cm, called “Siebdruckplatte” in german.
• some wood screws
• wood glue

Electronics:

• Arduino Due
• Arduino Mega Proto board
• 3 Pololu DRV8801 DC motor driver
• 2 Adafruit alphanumeric displays
• Adafruit Huzzah ESP8266
• IRL2203N N-channel MOSFET
• 12V solenoid
• LiPo battery, 11.1V, 3600mAh

Building the main body

If you want to build your very own paint machine, plans and software are available in the links section. I’ll experiment a bit and don’t have thousands of pictures like I have in my other builds, but a couple of videos that document how I’ve built the machine. It’s not a super detailed step by step instruction but I think you get the idea. I used a variety of tools here but I’m sure you could come along with a jig saw, a drill press and a couple of hand tools.

Wheels

Print Head

The print head consists of two parts, the carriage with the motor and the real print head. That means it is relatively easy to swap the print head with the spray can for some other print head.

Electronics

For the main board I chose an Arduino Due, that I had laying around for a long time. The Due is a 32-bit controller, running at 84 MHz, so it’s quite fast and it has a lots of pins for IO.

All extensions are soldered on an Arduino Mega Prototyping shield. The three DC motors are powered by a small DC motor driver, the Pololu DRV8801. This driver can handle 8V-36V and up to 1A continuous (2.8A peak). Every motor driver needs a PWM signal to control the speed and one pin to control the direction.

The motors have an encoder attached to its axle. The encoder generates 64 ticks per revolution. The encoder uses 4 wires, Vcc, GND, encoder A and encoder B. Problem is, I routed the power wires for the motor parallel to the encoder lines. Everything seemed to work fine, until I finally tried to drive the motor a couple of hundred ticks in one direction and then back to the previous position. That simply didn’t work. I had to rewire all three motors, using shielded cables for the encoders. After that I couldn’t see obvious errors in the positioning any longer.

As the motors are DC motors and not steppers, positioning works quite different. I’m using a simple PID-control loop, which works OK-ish. Sometimes the motor overshoots the position and has to turn back a bit (can also be seen in the video). If I decrease the amplification a bit, the motor no longer overshoots but in other situation didn’t have enough power to reach the desired position, e.g. when printing uphill. That would result in a humming, stalled machine. A little nudge then helps. I chose the DC motors because I thought that steppers would require more power to operate, especially require current to hold a position, whereas the DC geared motors hold the position simply because of their gear reduction. Still I might try steppers, maybe in a new version.

Another problem was the power supply for the ESP8266 breakout board. When powered via the main 11.1V battery, the power regulator got extremely hot. Sometimes the wifi connection simply broke off, sometimes the board seemed to get stuck in a reset loop. To help with that, I added a switched DC-DC converter and added a 1000u cap on the 3.3V lines. The ESP8266 is much more reliable now.

Software

The Arduino firmware receives commands via the serial port from the ESP8266. There are commands that can be used to control the machine remotely, like “run left motor on speed x”. The main command is sending values for the bitmap to print. Currently one pixel is configured to be 35mm * 35mm. The complete bitmap is then (4:3, 61px * 46px).

The ESP8266 acts mainly as a WiFi-Shield. The firmware tries to be as transparent as possible. It opens a wifi access point and waits for incoming socket connections. Then it just acts as a bridge between the wifi and the serial connection.

When started, the Android app tries to connect to the wifi access point. After the connection is established, the paint machine can be driven with tank like remote controls.
To send a bitmap to the paint machine, the bitmap is selected from the gallery. Minimal image processing, like level adjustment, is possible before sending the bitmap.

Conclusion

There are a couple of improvements I want to try. As the print head can be swapped, I want to construct a couple of different print heads. I have some ideas for that and I’m already prototyping one.
A custom Arduino Mega shield with all driver chips on it would be nice. If you would be interested in a custom PCB, please let me know in the comments. Also maybe a custom enclosure for all the electronics.
For the motors, I could think of a paint machine that uses only stepper motors. Maybe that would require a bigger battery but that is not really a problem.

This was a fun built, definitely my biggest and heaviest. I enjoyed building the mechanical structure, wiring all the electronics, writing the firmware and the client app. I tried a couple of new techniques and materials. Failed a lot and learned a bit. Wood for the main structure was a good decision. It took much longer than I thought with drilling, cutting and sanding, but it was worth it. A frame completely out of aluminum profiles would work fine, but would look much colder, I think.

This machine is a conversation starter, even if it was not primarily designed as such. I haven’t printed very much, because it’s November and we’re in Hamburg, but the couple of times I was trying it out, it made some heads turn. Just after the very first print in front of our office, an elderly neighbor approached me, while I was still sitting on the sidewalk, fiddling with the machine. I was expecting a couple of harsh words about vandalism, etc.

But it went like this:

He: Oh, what is this?
Me: That’s a huge printer. It has just printed this here. *pointing*
He: Really? Hmm … *looks at the print* … *looks at the machine* Everything built yourself?
Me: Yep.
He: Hmm. *nodding* Tell me next time you print something. Want to see it in action.

:)

Links and downloads

• github repository with source code and plans
• More hi-res pictures on Flickr
• Oz was a famous sprayer here in Hamburg

I always loved watching marble machines, especially the creations of denha. These little machines are super cute and very well made. So a marble machine was on my todo list for a very long time.

To start easy, I decided to build the most minimalistic marble machine I could think of. Just one oval and a single lift mechanism.

To form the oval tracks out of 2mm brass I bend them in a bending jig and pressed them into a template, milled on my ShapeOko. The support posts where also cut on my CNC out of 2mm brass sheet.

After soldering the support posts to the rails and soldering the lifting mechanism, everything got test assembled on a piece of MDF.

Of course, such a marble machine needs a nice base. To find a nice piece of wood I spent a couple of hours at a wood shop for local and exotic woods. I bought a piece of african padouk. That piece then got cut to length, sanded (a lot!) and finished with linseed oil.

Finally, putting all together, it needed quite some tweaking to get it robust and not losing a ball every now and then. The balls are 15mm in diameter and made out of stainless steel.

This was the first time I worked with wood and brass. Always good to increase the possible materials. I enjoyed working with wood, despite the mess that is makes in my small workshop.

Links

• More pictures of the build process at Flickr
• Check out denha’s Youtube channel. Lots of awesome marble machines.

Since I started playing with electronics, I dreamed of building my own robot. Not buying a kit, but making every part of it myself. It took quite a while, almost 11 months, not full time, of course, but on and off, with smaller projects and work in between.

Last year I bought a small used lathe, then a small mill and beginning of this year, 2014, a ShapeOko 2 CNC mill. Every machine has it’s own rabbit hole. Hard to not get lost for a beginner like me. So many ways to screw up. I checked a couple.

So here it is, my very first robot, halfbug. All parts are machined and manufactured by myself, not counting the Arduino board and the servos. Everything is screwed or clamped together without any glue.
Well, almost.

Manufacturing parts

Manufacturing all parts took most of the time. I started designing parts in QCad (2D only). Then if the parts were out of plywood or aluminum plate, I would import the model into CamBam. After that, sending the gcode with the Universal Gcode sender to my ShapeOko 2. Then milled and deburred.

Non flat parts are manufactured out of aluminum. Some parts on the lathe as the tail wheel and some wheels for the head turning. Everything else on my mill.

Here are some of my screw ups:

• I milled the hat out of 3mm aluminum plate. That came out really solid. Much too solid for the tiny servo that tilts the head. The new part was made out of 1mm plate.
• The structure of the head was milled out of 3mm plate with 1.5mm indents for easy bending. Problem was: the indents were on the wrong side.
• Legs and body were made two times. The proportions weren’t right the first time.
• The clamp for the turning servo was made two times. The first looked great, but couldn’t be attached to the base.
• The ribs for the battery holder were made two times. The first had only one rail and was not rigid enough.
• Many more …

Most facepalm moments came from sloppy design. The parts itself looked fine, but often doesn’t fit to the base structure. Maybe another (better) 3D CAD program would help. If you have suggestions (Mac), please let me know in the comments.

Power supply

Power comes from four AA eneloop batteries (Ni-MH). That gives around 6V when fully charged and low as 4.6V when almost discharged. I’m routing power through a Pololu adjustable step-up/step-down voltage regulator. That is tuned to deliver 6V on the output. These 6V are then fed into Arduino’s Vin and used to power the servos. 6V on Arduino’s Vin may be a bit low but seems to work OK.

Electronics

The brain is an Arduino Micro. That is quite the same as a Leonardo, but smaller and designed to fit on a breadboard. I soldered a couple of headers to the board to be able to connect all five servo connectors. As the Micro has no mounting holes, I glued neodymium magnets to the board and the body. That worked well.

The only sensor is a Parallax PING))) ultrasonic sensor. This one works really fine, better as most of the infrared rangers I tried.

All servos are Hitec ones. I’m using HS-311 for the arms, HS-5485HB for the lifting and small HS-55 for turning and tilting the head. The HS-55 are quite loud, compared to the bigger ones. The servo for lifting the whole body needs quite a bit of torque, which the HS-5485HB has.

Software

Software is quite straight forward, a giant state machine, that takes input from the sensor, every now and then.
halfbug has 5 different movements, one regular forward movement, one turn (left and right) and one turn hard (left and right). In addition to that halfbug has a head movement (left-right-straight) or looks left when turning left. Both, leg and head movement is controlled by separate sub-state machines.

There was a gotcha with my software. I had a lot of servo jitter, as you can see in the making-of video. Turned out that the standard Servo library that comes with Arduino and the MsTimer2 lib don’t play together so well. I’ve checked the code a bit and I’m not sure what really the problem was. I would blame disabling interrupts, if I had to guess. Anyhow, I removed the timer lib for now and the jitter is completely gone.

Wrap-up

This was one of my longer running projects and there were a couple of times where I had doubts if I would ever finish it. In the process I had some fails but mostly it was a matter of re-designing and re-doing a part. Then, the first time halfbug was doing push-ups on my desk, super cool. I learned a lot and have still a ton to learn.

If you like robots like this one, be sure to check out Beatty Robotics. They do awesome robotics projects.

Links

• More pictures at Flickr
• Arduino firmware and 2D CAD files at github
• Parallax PING)))
• Pololu Adjustable Step-Up/Step-Down Voltage Regulator S7V8A
• QCAD
• CamBam
• Universal Gcode sender