Johannes Fischer

I want to learn "How to make (almost) anything"!
That's why I take part in the Fabacademy 2014.

More about me

Every Week we get a new assignment:

Back to assignments Permanent Link here

Website and Final Project sketch

This is what I have done for Assignment 1. For me it is very convenient to have just a single page where everything is included. This keeps all the information in one place and allows very simple updates (just one single file). Thanks to the nice template, the website looks quite impressive, too!

Back to assignments Permanent Link here

Computer Aided Design

Our task this week was to play a little bit with many different CAD tools and to model the final project.
Download sources of this weeks assignment

First of all I wanted to learn Inkscape and I designed a chess board with it. I was impressed that you can draw very precise with Inkscape and it has many helpful things build in like grouping objects and rotating/mirroring. In the toolbar there are boxes where you can enter numerical values for the position or the size of the object, what I found very helpful.

After that I carried on with 3D-CAD-Tools. I played a bit with SketchUp and I was very impressed how easy 3D-modelling can be! I think SketchUp is a very good starting point for everybody intersted in designing 3D objects.

DesignSpark Mechanical
I had my project already designed in OpenSCAD, thats why I wanted to try some other CAD-Tools I ever wanted to learn. DesignSpark Mechanical from RS-Components was suggested to me and so I started using it. Since I was used to scripting 3D-objects in OpenSCAD, it was quite difficult to get used to having a fancy GUI and buttons. But I figured out quite soon that it is very powerful, especially if you want to change something after you have finished your design. By grouping objects logically that belong together, you are able to simulate the behaviour of your machine, for example by clicking and dragging the x-carriage.

DesignSpark is very powerfull because it has a large online component database by RS-Components. Unfortunately not every part of their product range is available as a 3D-design and I found only a hand full of mechanical components in the database at the moment. Sadly I found no components I could use in my design, but I believe that it is the perfect tool for designing housings for electric circuits and the like.

Inspired by the idea that you can get designs for "of the shelf"-components online I looked at all the companies where I buy these parts and found out that all of them have 3D-Designs of their parts available for free! That was a great insight for me, because I can design the whole machine in more detail much easier without having to measure and draw every part myself. I was impressed by the huge amount of available file interchange formats. For me "iges" and "step" worked very well, but the step files I got had the advantage that more objects in one import-file could be grabbed separately.

OpenSCAD Animation
I had my final project already designed in OpenSCAD. So I thought it might be a good idea to simulate some movements in OpenSCAD. To achieve this I used the variable $t, that goes from 0 to 1 during the animation. All the movements are now done by incrementing $t. After adapting the source a little bit I was able to enable the animation mode in "view->animate". I entered 2 for the FPS and 12 for the steps to reduce the size of the animation. After activating "dump pictures" all the images of every step get saved to the same folder with names like "frame00000.png". Afterwards I created an animated gif out of all the single images by using imagemagick. A simple "convert -delay 50 -loop 0 frame000* animation.gif" did the task for me!

Afterwards I wanted to have the ability to use my component library in open source CAD tools. For this reason I tried to use FreeCAD, which seemed very promising. The learning curve is quite steep, but it does seem to be very powerful. Compared to DesignSpark, it has some shortcomings and some benefits. But I am sure it will do a great job for me!

Back to assignments Permanent Link here

Computer Aided Cutting and Press-Fit Construction Kit

Our task this week was to try computer aided cutting with a vinyl cutter and a laser cutter and to design a press-fit construction kit.
Download sources of this weeks assignment

Playing with the Vinyl-Cutter
I started using the vinylcutter with the device-driver from the vendor. I figured out quite soon that the cutting software only works with vector grapics and that eps can also embed raster images!
I wanted to make a T-Shirt with objects in multiple colors. It turned out that the results are not very precise (i guess this is due to scaling), so the single pieces did not fit perfectly. But the tolerances are in a very small range, so the result looks quite nice.

Afterwards I wanted to use the fab modules for vinyl cutting. Thanks to the great instructions on the mailing list by Sherry and Jean-Baptiste, I was able to set up everything properly. The fab modules are very nice and powerful. It turns out they are much easier to use than I had expected (on ubuntu)! You simply plug in your device, go to the printer settings, enter your password to become root, add the new found device as a "Generic Model" as brand and "Raw Queue". What is very important here is the name of the device, so if you want to use a vinyl cutter you have to enter "vinyl" as name.
Working with the Silhouette Cameo was a bit tricky, as it needs some modification of the generated .camm file. First of all you have replace all the PU (PenUp) commands with M, and all the PD (PenDown) with D, otherwise all the movements are also cut. Furthermore the start sequence has to be changed from (something similar to this):


Afterwards you can send the modified .camm file to the printer with the fab_send tool. But be careful, because the "print" is twice as large as it should be.

What I like a lot about the fab modules, but what might be a bit confusing in the beginning, is that every single task has its own command. So for example if you want to vinyl cut something from a pixel image, you have to use the command make_png_camm, if you want to make the same file on an epilog laser cutter you use the command make_png_epi. Thanks to the nice modular framework implementing your own features is quite simple. For example, I wanted to vinyl cut a half-tone image from a png, so I adopted the code to create a command for half-tone vinyl cutting .

Designing a Press-Fit Construction-Kit for the Laser Cutter
I was working with a dual layer cardboard that is about 6.6 mm thick. In the first step I wanted to come up with good settings for cutting and graving the cardboard. I started with small values and incremented them in small steps until I had good results. Afterwards I wanted to find the right cutout-width for the joints, again by varying the size in small steps.
Afterwards I started designing the construction-kit. I wanted to build a minion figure where the body is fixed (two press-fit joints meet each other) and the other parts (eyes, hands, feet) can be attached in any position (one press-fit joint meets plain cardboard).
The Body
The body consists of small top and bottom rings, two larger center rings, 8 connecting straights and 16 connecting bows.

I wanted the body to be as big as possible but use as little material as possible. For this reason I have split the big ring into four identical sections, 90 degrees each. The problem with this setup was that these sections had no joints and so the stability was very poor. But I remembered the connectors of my toy wooden railway and after added these connectors the stability issues were solved.

The other Parts
All the other components should be attached and detached quite easily. For this reason I designed a bunch of universal connectors in different sizes and with an step of eighter 45 degrees and 60 degrees. The glasses, arms or feet can be connected to the body with these connectors and a bunch of different connecting rods.

Playing with flexible structures
I was very impressed by the images of the flexible laser cut structures. For this reason I wanted to play a little bit with this technique. I found a test pattern on the internet that I wanted to test on the cardboard. Unfortunately the design was for plywood so the cuts were a little bit too close and the cardboard went on fire! So I scaled the pattern a bit larger, and I could cut a flexible cardboard. Sadly the result was not too impressive, so I tried another pattern on plywood, and that worked quite well. But the result was not as impressive as I had expected it, so for achieving better results you should take the right wood and better settings for the spacing.

Back to assignments Permanent Link here

FabISP production

Our task this week was to make the FabISP, a small In System Programmer for AVR Microcontrollers. As it turns out, my friend Murphy and his law was working aginst me this week ;-) !!!

Milling the PCB
Milling the PCB was not so easy for me, as we only had a 0.5mm tool head here and the design needed a 0.4mm tool head. I was cheating a bit, telling the fab modules I was using a 0.4mm tool but using a 0.5mm tool for milling afterwards. The result is that all my pads and connections are now a little bit too small. Because of that, some of the connections lifted off the board and were cut during the milling process. But with a little bit of repairing the PCB was usable.

I was milling my board on a different CNC than suggested by Neil. For this reason I was using the make_png_g to generate the G-Code for our machine. After some small adaptions I was able to use that code for milling the PCB. But I had to increase the spindle speed to the maximum (24 000 rpm), otherwise I broke the tool head instantly.

My setup for milling the PCB

Some connections are missing (marked in red)

Soldering the PCB
Soldering the PCB was also not so easy for me because I had to repair the PCB and we just had 0805 components around, but the PCB is designed for 1206 component size. It turns out that it is possible to use the smaller parts in this layout, and also bridges worked well (maybe due to the smaller sizes after milling ;-).

For repairing the disconnected parts of the PCB I was using some special insulated wire, that can be uninsulated with the heat of the soldering iron. This was very helpful for this task!

The finished FabISP

Programming the FabISP
I was using a Atmel AVRISP MKII to program the board, that we have in our lab. After adapting the Make-file (different programmer and different quarz) everything should have worked out of box. As it turned out, that was not the case. I did not solder the jumper for the voltage supply but I was not aware that the AVRISP MKII was measuring the voltage of the target board (my other programmer doesn't have this feature, either). The error message you get from avrdude is not very helpful for debugging. But with the help of our electronics-expert (thanks a lot for that) and the Atmel AVR-Studio (that was indicating this problem almost instantly) I was finally able to program the programmer (after closing the jumper for voltage supply).

Testing the FabISP
After connecting the FabISP to the computer it registers as:

I am using the 10 pin connector specified for AVR ISPs in my other designs and development boards. So I had to build a small adapter cable that converts the 6 pin to the 10 pin layout. After that I was able to connect to my development board without any issues.

Hint for using avrdude without sudo in Ubuntu
If you get some messages like the ones below using avrdude, there is a small trick other than using "sudo avrdude":

Generally it is not a good idea using standard programs with sudo (security issues)!! So the workaround is to just create a new file at "/etc/udev/rules.d/80-usbprog.rules" and enter the following content to it:

After disconnecting your programmer and reconnecting it again avrdude should work fine without sudo.

Back to assignments Permanent Link here

3D-Scanning and 3D-Printing

Our task this week was to design something that can only be produced by 3D-Printing. Moreover we had to perform 3D-Scans on real-life objects.
Download sources of this weeks assignment

This week I wanted to create a physical random generator. The idea was to have an object with one hole in the top where you can insert a small ball and four possible outlets, where the ball might be released again.
The main parts, where the randomness is generated are a helix, where the ball is spinned around the center axis of the object, a funnel afterwards, where the ball is guided to the center again, and four outlets at the and of the funnel with boxes to catch the ball.

All those parts where embedded in a small tower, and the final object looks like that:

Printing the object worked right out of the box, and thanks to the soluable support material the result is perfect:

Thanks to the fact that the 3D-printed balls are not symmetric in the inside (because of the infill), the random generator works really good (as long as the floor is perfectly horizontal ;-)!

After the perfect printing result I wanted to get similar scanning results. As it turns out, there is not one 3D scanning process that is suitable for all objects.

First of all I wanted to go BIG. I already did some 3D-Scans with photogrammetry, mostly faces, and the results were quite good. But this time I wanted to go much bigger. I wanted to do 3D scans of some historic sights in vienna! I have to admit that I had some great step-by-step tutorials on How To do photogrammetry properly and How To install VisualSFM in Ubuntu and How To improve point clouds in MeshLab, that helped me a lot during the process. But once you figured out the critical parts, the process is damn simple. Just take a bunch of pictures all around the object you want to scan, hand them to the 3D-photogrammetry software and let it generate the object from that images.

All the pictures for the scan.

All the pictures arranged around a sparse point cloud.

If all the images are aligned correct, the software generates a dense point cloud of the object.

The generated dense point cloud.

The reconstructed surface after cleaning the point cloud.

Here are some more impressions of other objects:

A huge tower on my way to the lab (large holes in the scan cause this artifact)!

The same tower but the uncleand pointcloud of the scene before remeshing!

A horse statue, scanned in very dark environment.

A sculpture of a lion (not reconstructed in best quality)!

Stephansdom in vienna, scanned with about 180 Pics, a bit too much for my hardware (so just lo resolution, no reconstruction of the point cloud).

As you can see clearly, some objects are harder to scan with this process than others. Moreover the quality of the source images is very important. I would suggest to take your pictures during a cloudy, bright day (gives very even light from all directions). I was impressed that the scan of the dome worked that well (I expected it to be much worse!). It turns out that taking multiple images from one point does not disturb the process, as long as you keep on moving around the hole object as well. Taking the pictures from the sky would be a great advantage here ;-)!

I remember someone has asked about 3D scanning from a video. I remember I did something like that a few weeks ago. My setup looked like that:

We mounted a USB webcam onto a LEGO train, lit the scene as well as we could and grabbed a video while the train was circling around the object. The setup would need a bit more tweaking (more light, better cam for sharper images, ...), but the result shows that the more pictures you have the better the results are.
The pictures where extracted from the video with ffmpeg, and afterwards used for the same processing pipeline as explained above. The command for ffmpeg is:

Where i specifies the movie, r is for the frame rate (how much pics per second you want to extract) and the last name stands for the file names of the generated images.

Resulting 3D-Scan of the Train-Scanner.
DAVID Laserscanner
Afterwards I wanted to try the famous DAVID Laserscanner. Sadly I was not able to get good quality scans with the line laser due to a much thick line of the line laser and too much ambient light around the scene. The DAVID Laserscanner is said to produce quite decent results, but the setup is very critical!

Scanning with a line laser (Note the reversed order: I was scanning the printed part ;-)!

DAVID Laserscanner - Structured Light
I did not care about those bad results as the new versions of DAVID also have a Structured Light Scanning mode, that looked very promising to me. After I figured out how to setup everything (the best way is to place the camera in front of the calibration panel and the beamer above the camera) the scanning worked very well. Fast (a few seconds for one side), textured scans, some postprocessing included and a shape fusion algorithm that lets you combine all the single shots to one scan (did not test that as the free demo does not allow export from that). If I need scanning, I will build a turntable and some setup with the david.

Scanning with structured light (Note: the beamer is projecting the checkerboard pattern on the calibration planes !!!! ;-)!

Scanning result of a my hand with the DAVID SLS

Scanning result of my face, exported in low quality due to the limitations of the free version.

Back to assignments Permanent Link here

Electronic Design

Our task this week was to design the "hello-FTDI"-Board and to make it.
Download sources of this weeks assignment

Designing the board
After I got used to eagle, designing the board was quite straight-forward. Just a few small hints for the next time: Do make sure to set up the raster properly in the board-window (units in mm, show the grid and 0.635mm raster, alt-raster to half size), the alt raster is enabled by hitting the "alt"-key and pads can be drawn as polygons with the same name as the electrical connection they extend. Also don't worry about the export of the image too much, as the diameters (or the dpi) are stored in the png-image itself, just make sure only the right layers are visible when exporting the image.
Many thanks at this point to everybody who helped me dealing with eagle, especially to Christoph.

Milling the board
Milling the circuit board was straight forward this time. Partly because I had a 0.4 tool head this time and partly because I had built my own sacrificial plate out of MDF, that makes the process now super simple! Many thanks to Roland (one of the founders of the happylab) for this great idea, now milling PCBs is great fun.

Soldering the board
The only problem this week was that all the ordered components did not arrive in time! Fortunately the lab has a lot of TTH components, that I placed onto the SMD-pins. Everything is working fine, but the board looks a bit weired now ;-)!

Testing the board
After checking the boards for shorts and checking all the connections I wanted to test the board if it is working properly. For this reason I wrote a small test program (NOTE: I connected the LED to PA3 and the switch to PA2)

Back to assignments Permanent Link here

Make something BIG

Our task this week was to make something big out of wood on a CNC.
Download sources of this weeks assignment

Karim, one of the founders of the happylab, found a nice software to create chairs called sketchchair. Although the software is a bit unstable, the idea behind it is great! So I gave it a try.

It is quite simple to use and has a kinematic test to try the chair before you make it:

I did not know that I am that flexible ;-)!

Unfortunately the export did not work well for me, so I went online and got one of the available designs. But this was also not very sucessful (as I found out in the first test), because the svg-file seems to be buggy and gets scaled when you want to convert it to a dxf. Moreover some paths were not closed (and could not be milled therefore), but there is an option in Cut2D to close open paths.
Anyway, after rescaling the file and reorganizing everything on my sheet of wood and fixing all the other issues I was able to mill my chair.

Milling everything lasted about two hours, afterwards I started assembling.

Unfortunately one of the pieces broke while assembling the chair. I had some material left so I milled a replacement part.

And here is how the final result looks like:

Back to assignments Permanent Link here

Embedded Programming

Our task this week was to try as many different programming languages and programming environments as possible.
Download sources of this weeks assignment

AVR for children
I have already used AVRs for some projects and as a computer scientist I know how to code in C and environments like Eclipse. But I always wanted to have a very easy to understand graphical user interface for simple microcontroller programming. Because Neil mentioned Scratch in his lecture, I wanted to have a similar tool for AVRs that is suitable for children. So I asked in the lecture and the answers I got were amazing:

At the moment we have a student in our lab from spain who is new to programming and AVRs so I wanted here to try all of them and find out, which one suits best for her. I also wanted to get some feedback on how easy it is for an electronic-novice to start with these tools and to have a comparison of all the pros and cons of every environment mentioned above.

First of all I was playing a little bit with the Arduino environment. I like the concept about arduino a lot, because the interface is very simple (compare it with Atmel-Studio ;-) and it comes with a lot of demo programs for a quick start.
But it turned out that setting up everything (in Windows 7) can be a hard task. I could not program the microcontroller due to some connection errors. So I wanted to burn the Arduino bootloader with the AVR ISP MKII, but the programmer was not recognized by the system. I had to re-install all the drivers (both from the Arduino UNO and from the AVR ISP MKII) first and burn the bootloader again. Afterwards everything was working fine.

Let the hello world board do something
I never worked with serial communication on an AVR so I wanted to play a little bit with it. I wanted to be able to switch the LED on and off from the PC and also read out the status of the button. So after setting up the switch and LED with those lines:
I was able to achieve that behaviour with those lines:

Just a small hint here: If you are using the Arduino serial connector instead of the FTDI it registers as /dev/ttyACM0 instead of /dev/ttyUSB0.

Playing a bit more
After those nice results I wanted to add some more stuff to the interrupt example. I wanted to have some different modes of the board (eg. LED is blinking all the time, LED indicates the state of the button, or after pressing the button the LED is on for 10 seconds) and you can select from the PC via serial connection which behaviour the board should have. Unfortunately I could not get this working, because there is some problem in the serial communication and it always gets a wrong character first and crashes then. Maybe this is because I am not using the FTDI chip (but a quite similar tool from arduino) for which the examples are opimized.

Back to assignments Permanent Link here

Molding and Casting

Our task this week was to design a mold, mill it on the CNC machine and cast a part in that mold.
Download sources of this weeks assignment

I liked the idea of casting bushings, but we did not have the right material for this task in the lab. So I decided to make a v-shaped roller bearing that can slide on a t-slot aluminium extrusion instead.

Designing the mold
I wanted to cast an off-the-shelf roller bearing inside the liquid plastic. So I designed a two sided mold that holds the bearing in place while casting the part.

Milling the mold
I took some foam to make the mold. As it turned out milling the mold was a bit tricky. First of all I tried milling the mold with Cut3D, but the result was quite rough.

Taking a ball-end mill instead of the flat endmill did not make the result much better.

Then I tried generating the G-Code with the Fab Modules. As it turns out, the Fab Modules can generate circular movements in the rough cut and make a second raster at 90 deg at the smooth cut in comparison to Cut3D. Thanks to these changes (and a smaller stepover), the milling-result was much better.

Rough Cut

Smooth Cut

After the milling was done properly, I carried on with casting. I placed the bearing inside the mold, closed the mold afterwards and clamped it.

Getting the liquid plastic inside the mold was a bit tricky as I did not expect the liquid plastic to be that liquid! (The next time I am going to design a funnel into the mold!).

After demolding the part I was quite pleased with the result. The plastic is much stronger than I had expected it!

One side of the mold was not strong enough so a little bit of plastic came out on that side. But with a small file I was able to fix this issue quite soon. It seems that I did not apply enough coating on the inside of the mold as the surface of the finished part is a little bit rough and a little bit of foam remained on the casted part.
All in all I am really excited by the potential and possibilities of molding and casting!

Back to assignments Permanent Link here

Input Devices

Our task this week was to design a new AVR-Board with an input device and make it.
Download sources of this weeks assignment

I was fascinated by the hall sensor this week. I read in the reprap forums that you can make very precise endstops with the help of a hall sensor. In the proposed design they are using a potentiometer and a comparator to convert the analog signal of the hall sensor into a digital signal of an endstop. I wanted to do that in software to have more capabilities (e.g. removing the hysteresis of the hall sensor) and have less components with temperature drift.

Design the board
So I started designing a small test board that is capable of both, sending the measured data to the PC (for the development process) and acting as a real endstop. I added a pushbutton to set the triggering level for the endstop and an LED to show the status.

Make the board
As I am quite confident now with the process of milling PCBs I wanted to experiment a little bit with a different tool. Here in our lab there are two guys who are milling their circuit boards with engraving bits and their results are very good (although they use a slightly different workflow).
In a first test I took a slightly too large engraving bit so my traces were really thin. Nevertheless the resulting board is working fine. The next I am pretty sure I will get the same results as with the 0.4mm endmill, but with slightly lower costs and (hopefully) a longer lifetime of the bit.

Programming the board
I started with the "hello world" code from Neil to get used to the behaviour of the hall effect sensor. Then I added the code that triggers the output whenever a specific value is reached (remember: it should act as a switch). I added some code to store the triggering-value of the sensor into the EEPROM so that it is preserved during power off. Unfortunately I needed a new makefile that was capable of both, compiling the source code and the content of the EEPROM. I found a good makefile at a great german microcontroller website that I adepted for my purpose. On the same website I also found a great tutorial to access the EEPROM .

Destroying the board
I was always looking for a good solution to get rid of the large ISP headers on small PCBs. So I tried to just press the ISP header onto the pads for the header while programming the chip. This worked surprisingly well for a while. But unfortunately I went off the pads once and fried the attiny. So I had to desolder the microcontroller with our IR-lamp. This worked quite well, but some of the traces lifted off from the PCB (due to the different milling bit). But after soldering the new chip (and the ISP header this time ;-) the board worked well again.

So my solution is to use the soldered ISP header for the development board and try the clip for ICs the next time for smaller boards or small series.

The board works very nice as a configurable endstop-switch! Whenever a magnet gets close to the sensor, the output is triggered (indicated by the LED). I have to test if the precision is better than the micro switches and the optical endstops by mounting the system onto my printer.

Back to assignments Permanent Link here


Our task this week was to make a strong and leightweight object with burlap and epoxy.
Download sources of this weeks assignment

I loved the idea of making a surfboard, as it was shown in the last review session. But I wanted to make a skimboard instead of a surfboard, as it is much smaller and so it is possible to mill in one piece on our CNC.

So the first step was to design the board. I was looking for a specific software to do this and I found out in a quick search that there are some well established tools for this task.

Among them, BoardCAD seemd to fit my needs best, as it is actively developed, open source, cross platform (even a web-version exists) and well documented.

The BoardCAD User Interface

The only drawback is, that it is quite hard for a beginner to figure out the correct order of steps to get some files for making your board.

  • Start the software (java -jar BoardCAD.jar)
  • Create a new board from an existing Template (File -> New)
  • Adapt the board to your needs. I resized it to get a Skimboard and adapted the shape by pushing the nose a bit down. But be aware that resizing only works in a 2D view.
  • Calculate the 3D shape from the 2D lines ("3D Model" -> "Approximate from Bezier")>
  • Render the 3D nurbs object (Render -> "Render nurbs model")>
  • Export the 3D object (File -> Export -> "Nurbs to STL/DXF/STEP")>
  • Export the 2D outline for cutting the burlap on the laser cutter (File -> Export -> "Bezier Outline to DXF Polyline")>

The 3D view mode

Shaping the board is done by dragging points

Milling the board
Milling the board was not straight forward as I had to do a doublesided milling and so I had to turn the board to the other side while it stays absolutly in place. To achieve that, I placed the origin to the center of the object and I milled two wholes along the center axis into the foam board as a first step. With the help of this two wholes I aligned the workpiece in the machine with two threaded rods. But because I did not have much space, I removed these rods for the milling process and installed them again for flipping the workpiece.

Drilling the holes to align the workpiece

Fixing the workpiece to the table

Workpiece is now aligned and fixed

In the first milling process, I scaled the object and accidentially lost all the tabs that I had already placed. So I had to prepare milling another board. In the second milling process the tabs remained but in the future I will place more of them (and thicker ones), because one of them broke and for this reason one side is a little bit thinner (but I was able to remove this issue by sanding the foam board). Unfortunately I only had a very small milling bit (6mm) so it took me some hours to get my board. For this reason I wanted to speed up the machining time. So I increased the spindle speed from 10000 rpm to 24000 rpm and therefore I was able to mill the board about 3 times faster.

The top is milled

The workpiece is turned

The bottom is milled

I am quite happy with the milling result (altough I will take a larger milling bit the next time!). I was able to cut the tabs with a knife very easy and I was able to get rid of the rough surface of the board by sanding it a little bit.

The top of the board

The bottom of the board

The nose was a little bit destroyed (because one tab broke)

A little bit of sanding resulted in a very smooth surface

The defect on the nose was (almost) removed by sanding

Cutting the burlap
I love the fact that BoardCAD is able to export the outline of the board to a dxf file. With the help of this file I was able to cut the burlap to match exactly the shape of my board. For the top pieces I designed the burlap-pieces to fit exactly the shape of the board and for the bottom I added some small overlapping parts with V-shapes at the corners.

One drawback was that our lasercutter can only cut 900 mm of length, but I needed to cut sheets that have at least 1200 mm. To achieve that I had to come up with a small trick. I was cutting the pieces in two steps by splitting the design files into two parts in the middle of the length. For cutting I unrolled just one half of the burlap sheets and stored the other half carefully at one side so that it does not interfere with the laser beam.

Preparing the burlap for the first halfside cut

The first half of the shape is already cut

Preparing the burlap for the second halfside cut

Preparing the laser beam with the end of the first cut.
Make sure that both ends of the cut match.

The foam core and the burlap pieces are ready for the epoxy

Composites round 1
Now that I had the foam core and all the burlap pieces prepared I was able to start working with the epoxy. I started with the two bottom pieces (one after the other) and after they were full of epoxy, I switched the board to work on the top side. Unfortunately I designed the overlapping pieces not big enough for this sharp angle and did not put enough epoxy onto these pieces so I had a hard time wrapping the overlap to the top side. The next time I will use some spray glue to fix the pieces to the foam core. Moreover I realized at this point that the burlap is a little bit too thick for the sharp details of a surf- or skimboard, so the next time I will use a much thinner material like fiberglass!
After all the burlap was covered with epoxy, I used some more epoxy to get really good infusion. To achieve that I had flip the board again and at this point it was really difficult, as the burlap was very heavy now and did not stick to the foam-core at all. After I rearranged the burlap again, I placed the board in the vacuum bag (that I had prepared with some vaseline in advance for a better release) and removed the air with a hoover.

The board in the vacuum bag (hint: the black parts in the image are from a removed company name)

This worked much better than I had expected, but unfortunately the weight of the epoxy was too much for the small foam core. I was glad that I had the result of the first milling process at my side so I was able to support the board with this core. The next time I will make a supporting structure for this task. Another issue was that I had some imperfections in the vacuum bag (and I did not use a foil to soak all the excessive epoxy because I wanted to get a smooth epoxy finish).

Composites round 2
Because of this issue (and some imperfections in the overlaps and some burlap-fibers sticking out) I had to do a lot of sanding after the first round of epoxy. This took me quite a while, but I was able to get rid of most of the problems. After cleaning the board from the dust I applied some more epoxy and put the board to the vacuum bag once again. This time I used tape to get rid of the stress in the foil and to be able to shape the corners better.

Back to assignments Permanent Link here

Output Devices

Our task this week was to make a board that controls an output device.
Download sources of this weeks assignment

For my final project I will need to control a servo so I wanted to play with servos a little bit in this assignment.

Because we have a stabilized laboratory voltage supply in the lab I did not have to use a voltage regulator on my board. The connection to the power supply is realized with small clamps, for this reason I have added larger pads in the corners of the PCB. Moreover I wanted to be able to control the servo from my computer so I added a header for the FTDI cable. But at the power supply voltage rail I added a solder jumper to be able to select which source is supplying the target with electricity.

This time I was also milling with my alternative milling bit but this time I got it correct and the result was perfect. After I had completed the milling of the board, I removed the small remaining parts of copper with a knife. Unfortunately I destroyed one trace below the microcontroller so I had to fix that before mounting the components.

The milled board with the fixed traces

Testing the board
After I finished soldering the board, I tested it the sample code.

The soldered board is driving a servo

For some reason one of my servos was just jittering (i.e. it did not move as expected) and the other one was missing some repositioning-information. I assume that this is because of the cheap noname servos, as the pulses are nice in the oscilloscope and a good quality servo did not have this issues What I realized is that the servos are drawing a lot of current in the moment they are moving and for this reason the voltage of the laboratory supply was dropping. For my final project I will place some good capacitory on my board to prevent the rest of the system from issues.
After playing with the board for a while, I added the routine for the UART communication. This way I am able to control the servo from my computer in small steps. I love the power of this approach as this will allow a lot of nice future projects!

The board is now controlled from the computer

Back to assignments Permanent Link here


Our task this week was to let two or more microcontroller boards communicate to each other via a networking connection.
Download sources of this weeks assignment

I wanted to use I2C, because I will need an I2C communication for my final project.

First approach
My first idea was to use all the existing modules and let them talk to each other. I figured out that all the attinys that we were using have a USI integrated and all the connection lines from this USI are connected to the ISP header. So I thought that it would be a good idea to come up with small doughter-boards for the USI that enables you to connect them. I also wanted to have a simple and reliable connection between the modules so I used RJ-11 sockets and cables.

Because I was using TTH components (and I had to connect the RJ-11 headers to the PCB), I had to add an extra step to drill the holes. We only had a 0.8 drilling bit for this task so I extended the area of the pads a little bit. For the RJ-11 connectors, I needed 2mm holes so I made them larger by hand later on.
I wanted to have three of these boards, so I placed 3 boards besides each other in an image manipulation software afterwards.

There are some USI I2C libraries available. I was focussing on the libraries that are distributed by Atmel (AVR310 and AVR312). Unfortunately one of the libraries is written only for the IAR compiler so I had to adapt it that it was working with the GCC, too.

Unfortunately my tests did not work as expected. First of all I was using self crimped RJ-11 cables, that had bad connectivity (I was using a tool for RJ-45 connectors and it did not work very well). The second issue was that the RJ-11 headers on the daughterboards were a little bit too large for some of my boards (or my connection headers were a little bit too short) so the connectivity was quite buggy.

The milled boards

One addon board for the ISP header

All three addon boards connected via RJ-11 cables

Two example boards connected via I2C from the addon boards

Second approach
Because the first idea did not work, I wanted to use a hardware I2C unit for my final project. So I designed a board with an ATMega88, programmed it with an arduino bootloader and connected it to a RAMPS board (that is an arduino mega with a sheild to control a RepRap 3D printer).
My controller board has a red LED and so I wrote a small arduino program that receives values via I2C and sets this value as an analog output for the LED. The example worked great and this way I was able to control the brightness of the LED from the RAMPS board!
I was worried a lot about bus speed (because of the long cables) and slowed down the frequency of the bus to 1kHz but as it turned out, it was working nice at 400kHz (but beware that this is a best case scenario as no other components where producing noise).
I wanted to add some more features (like controlling multiple features on the I2C board, adding a checksum, ...), but I did not have enough time to implement that as I had to finish my final project.

The I2C board with the LED connected to the printer controller board

Now that I have achieved that I really love the ability to use arduino for every AVR board!

Back to assignments Permanent Link here

Mechanical Design

Our task this week was to make a mechanical design for our final Project.
Download sources of this weeks assignment

So I started redesigning the rough sketch that I had designed for the final project proposal. I was just fokussing on the the tilting hotend this time. I thought it might be a good idea to keep the design as versatile as possible so I designed the mechanism small enough to fit onto a standard prusa 3D-printer. Moreover I switched from a circular shape of the bushings to a v-shape so that the object is better suited for 3d printing. Furthermore I have separated these parts from the rest of the structural frame for two reasons. On the one hand this allows me to control the orientation for printing to reduce support material and to define the orientation of the ringing on the surface (to align them for perfect matching). On the other hand I can experiment with different materials later on to optimize the behaviour of the bushings.

Back to assignments Permanent Link here

Application Programming

Our task this week was to write an application that interacts with one of our existing boards.
Download sources of this weeks assignment

I wanted to have an application that lets me control the servo from my computer.

I realized it with python, pySerial and Tkinter.

Basically I started with the and took the board from the output week. In the output week I wrote code that reads characters sent via the serial communication and sets the angle of the servo to a desired position (in 10 steps). So what I did was to achieve the same result as for example hitting 0 on the keyboard by sliding the slider to 0. You have to take care that there is a difference between the integer value 0 (from the slider) and the character "0" (from a keyboard input). So I had to convert the decimal value from the slider to a character, as the output board was expecting that. In python you can do this conversion easily with "str()": character_value=str(decimal_value)

The disadvantage of this approach is that you only get 10 positions from 8 bit, but you can easily adjust the range of the slider with one variable. So if I need more precision I will switch to binary interpretation on the output-board, set the slider to 255 and skip the conversion to charakters.

Back to assignments Permanent Link here

Applications and Implications

Our task this week was to decide what final project we want to make and come up with a plan on how to realize it.

Final Project
I want to make a 4th axis as an addon for a 3D printer. It takes a bowden-hotend from (actual design version) and should fit on a RepRap Prusa Mendel as a new X-Carriage. As I like the idea behind RepRap a lot, I will go with the standard principle ["take as many standard components as possible, make the connections with 3D printed parts and take some vitamins (i.e. some special parts)"] whenever I can. For this reason I am going to print most of the parts, including the v-shaped-bushings and the v-idler. The axis is driven by a standard sized servo and an extension for the servo arm. Because the printer is controlled by a RAMPS board (the most used electronic for 3D-printers), the control unit for the 4th axis is connected to the RAMPS-board via I2C.

Looking at it in more detail

what will it do?
My final project will tilt the nozzle of a RepRap style FDM 3D printer at about +/-30 degrees along one axis (not the z axis).

who's done what beforehand?
The printer (including mechanics, electronics and software) has been developed in the RepRap project, the nozzle is designed by Concepts for more-axis 3D printers also exist, like the Sextupteron.

what materials and components will be required?
I already have a prusa mendel 3D printer.

Parts needed to finish my project:
servo + servo arm
electronic components

where will they come from?
all the printed parts -> printed in the lab (costs depend on material/printing price)
some M4 screws and nuts -> I already have them, you can get them at RS-Componentes (estimated 2-3€)
some M3 screws and nuts -> I already have them, you can get them at RS-Componentes (estimated 2-3€)
some compression springs -> I already have them, you can get them at RS-Componentes (estimated 2-5€)
servo -> RC-store (1 pc., 34€)
servo-arm -> RC-store (1 pc., 5€)
hinge -> igus (EGZM-04-75, 2 pcs., 3€/pc.)
bushings -> igus (RJZM-02-08, 4 pcs., 6€/pc.)
hotend -> (1 pc., 70€)
filament screw -> (1 pc., 12€)
electronic components:
- ATMega88 -> RS-Components (1 pc., 2€)
- MOSFET FDC8884 -> RS-Components (1 pc., 0,3€)
- L78L05 -> RS-Components (1 pc., 0,1€)
- 2 way screw terminal -> RS-Components (1 pc., 0,3€)
- 3 way screw terminal -> RS-Components (1 pc., 0,5€)
- 4 way pin headers -> RS-Components (1 pc., 0,2€)
- 20 MHz resonator -> FabLab inventory (a few cents)
- some resistors (size 1206) -> FabLab inventory (a few cents)
-- 1x10k
-- 3x4k7
-- 2x125R (or less)
-- 2x500R (or more)
-- 1x10R
- some capacitors (size 1206) -> FabLab inventory (a few cents)
-- 2x100nF
-- 1x330nF
-- 1x1µF
-- 1x10µF
- 2xLED (red and green) (size 1206) -> FabLab inventory (a few cents)
- capacitor 10.000uF -> RS-Components (1 pc., 0,2€)

what tasks need to be completed?
1. get all the parts
2. assemble the mechanics
3. test the mechanics by hand
4. fabricate the electronics
5. add the actor to the mechanics
6. test the mechanics again
7. write the software

how will it be evaluated?
The final project is finished if the nozzle can be tilted to specified angle.

Back to assignments Permanent Link here


I published the source files of my final project (software and hardware) under the creative commons (by-nc-sa) licenc. This licence allows you to:

  • share the design with others, but tell them where you can find the design and who made it
  • reproduce the design for private, non-commercial purposes
  • adapt or improve the design and distribute it with the same license

I am also planning to publish this project in the reprap wiki.

Final Project

Back to final project overview Permanent Link here


I am fascinated by 3D-printers. But I am quite upset, that all FDM 3D-printers need so much support material. Support material costs a lot of time and money and is thrown away after the printed object is finished. For this reason, I would like to build a 4-DOF polar FDM 3D-Printer, which is able to print much larger overhangs.

The nozzle is tilted inwards

The nozzle is not tilted

The nozzle is tilted outwards

The nozzle is tilted to the left

The nozzle is not tilted

The nozzle is tilted to the right

Back to final project overview Permanent Link here


Designing the PCB
I started designing the PCB. I am going to connect the 4th axis to the printer controller via I2C (which is available at every RAMPS board), so I am using a controller with a hardware I2C unit. I decided to use an ATMega88 in a TQFP package. To get some more modularity and flexibility I added a MOSFET and an input for a thermistor to be able to control the temperature of the hotend later on (in a new iteration I will add another MOSFET to drive the fan from this board, too). Unfortunately the design rule check told me that my board is not millable, so I went etching it (Later I saw that the fabduino uses an ATMega168 in the same package, so it should be millable. I will check the fab library if there is a fabable package design for this part.).

The PCB after etching

Soldering the processor was a bit tricky, as the pins are very small, but with the trick of desoldering I was able to get nice and working connections. I was a bit afraid of the high current that the servos might draw (the datasheet lists a maximumg of 2A per servo), so I put some more soldering tin onto the high current traces.

The PCB after soldering

Assembling the bowden hotend
In the next step I assembled the hotend, that arrived unassembled.

The bowden extruder assembled

After the hotend was assembled, I realized that there was not enough space for the cables in the mounting plate for the hotend. So I had to enlarge the tube in the center of the plate.

The mounting plate adopted for the hotend

The hotend mounted to the mounting plate, now the cables fit

The bowden hotend mounted to the mounting plate of the tilting mechanism

Printing the Parts
I printed most of the parts in the lab. But the main frame for the x carriage was too large (even for my RepRap printer in the standard configuration), so I had to extend the build envelope of my printer to be able to print it. I achieved that by mounting the bowden extruder onto the x carriage. I also took a 0.9 mm nozzle instead of a 0.35 mm nozzle, what resulted in a speedup in the printing time (from about 13 hours to something like 3 hours).

I installed the bowden hotend to be able to print larger parts (220mm width)

Afterwards I was able to print the main frame. Unfortunately I was missing some steps (in the Z axis) so the first print was not high enough. Besides, I did not take the time to calibrate the new extruder, what resulted in a very oozing nozzle and a lot of stringing.

Printing the x-carriage failed, because the z axis was missing steps

Then I took the time to calibrate the extruder, slowed down the movement of the printer and decreased the acceleration. This way the printing result was much better, but unfortunately just as I went away the printer a knot in the filament formed and the print stopped.

Printing the x-carriage failed again, because there was a knot in the filament

I tried to print the x carriage once again, this time with reduced print speed, a different layer height (0.5 to match all the details) and a better infill. This time it worked!

Printing the x-carriage worked

Smoothing the surface of the tilting rings
I realized that the tilting rings had some imperfections on the surface just after the printing process. So I had to smooth the surface to achieve a nice movement of the bushings.

Imperfections on the tilting rings

Imperfections on the tilting rings removed

Imperfections on the tilting ring guide

Imperfections on the tilting ring guide removed

Assembling the tilting parts
In the next step I assembled the tilting rings with the hotend mounting plate and the igus joints. Unfortunately the igus joints did not arrive in time so I had to print replacement parts and was not allowed to tighten the screws. I had to drill every hole to fit the expected diameter.

Replacement for the igus joints

The parts needed

Drilling the holes

The main parts assembles

All parts assembled

Assembling the x carriage
Then I carried on mounting the tilting parts onto the x carriage. I had a hard time inserting them into the mounted tilting ring guides, so I had to disassemble the servo arm and one igus joint. (Maybe it is better to insert everything together the next time!)

One guide for the tilting ring is mounted to the wall of the x carriage

The other side is mounted with compression springs

The x carriage assembled

The x-carriage from the side

Attaching it to the printer
In the last assembly step, I attached the hotend and a 80mm fan to the x carriage. Then I removed the old x carriage, installed the holders for the linear bearings and connected the belt to the frame.

Attaching the hotend and a fan to the x carriage

Removing the old x carriage

Installing the holders for the linear bearings

The new x-carriage installed

Programming the controller
I wanted to use arduino to program the controller board. To achieve that I followed the very nice tutorial on how to use custom AVR boards for Arduino . First of all I had to come up with a board definition for my controller and a suitable arduino bootloader. Then I played a bit with the wire library to get I2C working and finish the networking assignment. Afterwards I used the servo library to implement the desired functionality.

Adapting the printer firmware
For the first prototype I altered the marlin firmware that I am using on my printer. I added a new command (M700) that takes an S argument with a value from 0-250. This value is sent via I2C to the servo controller board, which puts a signal pulse from 1000-2000ms to the servo. At the moment, this is just the basic functionality implementend to play with the feature, but for the future there should be some more features (servo center, servo reverse, servo amplification, integration to G-Commands, more axes, more nozzles, ....).

Back to final project overview Permanent Link here


After one week working hard on my final project, I finally achieved my goal! The axis is installed on my printer, it is connected to the printer controller via I2C and the firmware is modified to interpret the new G-Code-Command for the new axis. A simple test object was printed (with manually edited G-Code), and the result is promising (I was able to print 60deg overhangs).

The axis installed on the printer

The axis tilted

A closer look at the nozzle (from the printbed)

The servo and electronics are located at the back

The compression springs provide stability for the tilting mechanism

First test of the mechanism with a manually edited G-Code (images extracted from a video)

You can download the sources of this project (includes instructions and BOM) and make such an upgrade for your printer, too.

Unexpected Problems
- imperfections in the surface of the 3D-printed parts -> sand the surface
- servo horn I wanted to use is not available -> design a new servo arm
- some parts of my printer were destroyed while travelling with the printer -> 3D print replacement parts
- heater wires do not fit in the designed hole -> make the hole a bit bigger
- bushings may not arrive in time -> 3D print replacement parts
- design rule check tells me that the package is not millable -> etch the pcb (also results in a more durable PCB)
- build envelope of my printer was not big enough to print the x-carriage -> extend it by using the bowden hotend
- printer is missing steps on y axes due to too much weight -> slow down printing and reduce acceleration

Lessons learned
- spiral development works great
- working in small steps helps achieving the goal
- have enough spare parts available
- keeping the design modular helps a lot
- expect everything to fail
- don't get stuck in the details, keep focused on the big picture

Further improvements
- explore the full potential of the new axis
- mount a self made heating to save space
- build a bigger printer (the large x-carriage reduces build volume!)
- improve sliding and stability of the bushings, test different materials and lubricants
- use the heating feature on the i2c board
- make the firmware more general
- come up with a slicer that takes account of the new printer feature

Back to final project overview Permanent Link here


More overhangs
My goal was to achieve something like 80 degrees of overhang. In the first demo, I was taking the result of a slicer (slic3r) and added just the commands for tilting the nozzle. This was just a quick&dirty test and I was able to get 60 degrees of overhang. But to go further to something like 80 degrees I had to write my own G-Code (positioning the nozzle in X and Z direction, tilting the nozzle).

So I went on and made the G-code for a small demo piece that had 40 and 80 degrees of overhang. There are 8 lines with 0 deg overhang, 8 lines with 40 deg and 8 lines with 80 deg. Printing the 80 degrees of overhang was no issue at all, except somehow there was a mistake as the tilting was done 2 lines too early. You can also download the G-Code file to try it yourself.

Printing 80 degrees of overhang (note the error at the tilt as the hotend was 2 lines too early)

Who am I?

I am a computer scientist from a small town near Salzburg (Austria). At the moment I live in Vienna to be able to attend the Fabacademy. I bought an FDM 3D-printer two years ago and I have successfully replicated it ;-)! I am interested in expanding the build volume and the capabilities of 3D-printers!