Menu

Monthly Archives: April 2014

3D printing, maker movement, open source, crowdfunding. This seems to be a sequence of up-to-date buzzwords. But they are somehow related to each other as they are with the T-Bone project.

In former times many people were makers. Farming and handicraft were not only professions, there were parts of most people’s daily life. This changed with the age of industrialization and increasing division of work. Productivity and diversity of available products rose exponentially. But also the dependency on big organizations and the necessary capital. Innovation was necessary to gain a competitive advantage and was kept as secret.

Digitalization and the Internet aroused a second industrial revolution. Now information can be replicated and shared for almost no cost. Especially intellectual work is affected by this development. Open source projects like Linux or Wikipedia are good examples of sharing work and information for everybody’s benefit.

But how should people buy food or pay their rent if their work is shared for free? Some scientists hit over this issue and invented the Street Performer Protocol. The idea was to collect money for a certain creative work like books, music, movies, or even software. If the necessary amount is gained, the artist release the creation to the public domain. To build up trust and beware from fraud, the money is collected by an escrow agent.

Street Performer (Source: P. Fabian)

Sounds familiar? Right, this is exactly how crowdfunding is working. Projects like the T-Bone are presenting ideas they think others will benefit from. But it extended the concept by tangible goods. People cannot only create, but also produce things they think others would like.

This leads to the two remaining terms, 3D printing and the maker movement. With a 3D printer it is possible to produce physical goods. Models for countless things are available on the Internet. Even parts for a new 3D printer can be printed. Oversimplified a 3D printer can replicate itself and any other object. In reality available materials, quality and complexity are still very limited.

Remains one open question: Why the T-Bone? The name is a remix of the underlying BeagleBone and the three-dimensional applications it is used for. From the name it was a short jump to the logo. And to the shape. Because the board is not only the platform for our project, but also the ambassador. See it and remember the name.

For sure it’s not the most simple or convenient shape. But is has a meaning. That’s our idea of making, not only producing things.

Anatomy of a 3D Printer

For a 3D Printer you need three simple ingredients:
- The printer hardware itself
- The printer electronics
- the printer software

Obtaining the printer hardware

The most common and easiest to assemble RepRap 3D Printer hardware is the Prusa RepRap. There is an excellent assembly guide which makes assembling your Prusa a breeze. On the rewrap Wiki there is an extensive list of materials needed, but the easiest is to get some kits:

(Disclaimer: This i just a list of companies offering Prusa kits. We do not know all of them and have not tested them – so check them out carefully)

You may even get parts easily on Amazon or eBay – but normal eBay or Amazon precautions are advised …

Some of the above shops already sell the Prusa i3 iteration – which is an improved and even more simplified version of the original Prusa. There is an excellent assembly instruction available too. Still we do not fully recommend this kits since the Prusa i3 is still in development. If you build your 3D Printer in half year or so … then it will be yours. Most description and parts are still for the original Prusa, slowly migrating to the i3.

Another very interesting variant to consider is the MendelMax which is mechanically a bit different but basically the same printer.

Getting the printer electronics

Getting the printer software

The 3d printer prints 3D models with plastic. That’s it. But to do so you need two parts:

A 3d model

a representation of the 3D model the printer understands

The 3D Model is created using a CAD program. The nice guys over at hacakaday have compared OpenSCAD, Blender, SketchUp, FreeCAD, AutoCAD and Solidworks to design a 3D model – one of the programs should suit your needs and/or budget.
Or you can browse thousands of existing models over a t Thingiverse.

Those models needed to be converted to a language the 3D printer understands. This is called GCODE. It contains al paths the 3D printer has to print to get the model to reality and also extra instructions to ensure that the hot end is hot and the fans are running … It is a bit like PDF or Postscript for traditional printers.

To give you some impression of the features of the Trinamic motion and motor drivers. It is far easier to understand the advantages with a real world example. Let’s do some configuration walkthrough of the development machine.

It is all in the code

The biggest advantage of the motor drivers we are using is that everything is defined in software. All aspects of the motors can be configured from the central printer configuration. As you seen in the screenshot above it is done in JSON to make it super simple to configure.

Step by step

We want smooth running motors with fine resolution – so we set the micro-steps to 256, because we can. All other settings like the max-speed is given in mm (mm/s to be really precise) so we have to give some steps-per-mm to convert the micro steps to mm. And since we have constant jerk motion wo do not only configure the max-acceleration (in mm/s^2) but also the bow-acceleration (in mm/s^3, which is jerk and may become renamed during development).
At high speeds we do not want to run at micro stepping – we give up some torque since the motor coils are not always running at the maximum rating. So we set the full-step-speed after which we fall into full steps (this settings of 25mm/s proved a bit on the high side).

More power

The basic power applied to the motor is configured in current – the nominal motor current. The Trinamic drivers ensure that the voltage is adapted so that always the correct amount of current goes into the motor. The setting is (like all current settings) done in Ampere – the software converts it to internal values for you. So forget fumbling with tiny SMT potentiometers and your multimeter to get a rough estimation of the motor current. It is in the config.

But we have much finer control over the motor. If the motor is not running we do not need the same amount of current as if the motor is running – hence we can reduce it with hold-current – here a relaxed 0.5A. When accelerating we add some more current to ensure that we do not miss steps – so acceleration-current increases it a bit to 1.2A. Also if the motor is running real fast we increase the motor current in high-speed-current to 1.2A too.
And to ensure that we do not reduce the current to early we set the downscale-delay to 100ms – so that the driver always waits 100ms before it changes to a lower current setting to ensure that the mechanic already settled …

Configuring the bed

This printer works with some real end-stops – so we have them configured here. We are still in the process to switch to a complete end-stop free setup. We have a right end-stop with negative polarity – which means it is active low. the left ends-top is virtual and 220mm from the right end-stop. The Trinamic motion driver will treat it just like real endstop – so we can ensure that X never goes below 0 and we never drive beyond 220mm from the right end-stop.
The homing-speed is configured separately since we want it a bit faster than normal speeds – since we just want to hit the endstop – the high homing-acceleration ensures that we stop abruptly after we have hit the end-stop. The much lower homing-precision-speed is used to gently find the exact location of the home switch – just like most other rerap firmwares as well …

Is that all?

Yes, for now …
Ok, but that may not be the end. In the Reprap Forum somebody asked what about the possibility of configuring the exact power distribution between the motor coils for each micro step. This is some very detailed motor current configuration which may be exposed in later development steps. The Trinamic motor drivers allow two very interesting configurations to smoothen and improve the motor run:

Those settings are really advanced and allow very detailed configuration. They also done in software and not very hard to implement. But for the first step we left it you. But surely they will be accessible in the near future.

Having a CNC machine without homing is a major pain. Wiring and debugging electric end-stops is a major pain, too But you can’t have one without the other.

Wrong, you can:

The Trinamic motion control chips support the great stallGuard feature. It is able to detect load on the motor. In the video above we just wired the X-axis motor on the current development board (not t-bonoid yet). The other cable is just for power. Nothing else …

With stallGuard we can easily automate the X-axis homing without using end-stops:

I switch on power (yes this switch of the power supply is awkward: 0 means the power is not switched off …) – but you can see the LEDs on the board light up.

The motor is automatically calibrated for Stallguard use – this is the slight wiggling you see in the video. It takes some seconds.

If the motor is configured and calibrated we just drive it to the left until the mechanical structure stops the motor (yes we drive it with little power). If the motor stalls we know the left boundary.

The same is repeated for the right boundary.

And if we know the boundaries we can position the X axis right in the middle.

The second half of the video just shows that it works with another arbitrary start position. Nifty, isn’t it? And much easier than wire and debug the end switches.

Does it make sense to develop another Hardware control for CNC and 3D Printing? There is the great GRBL for Arduino, the TinyG software and hardware. Especially for 3D Printing you got the famous RAMPS board with the Marlin or Teacup firmware and many others. Recently more powerful solutions like the Smoothieboard emerged. So what is the point in adding just another hardware and firmware platform?

The birth of T-Bone

For several reason we know Trinamic products very well. And we love CNC machines. I’m tinkering around with a Reprap Mendel and Jonas just bought a ShapeOko2 CNC mill. Just at this point he got the idea to create a controller board with Trinamic chips and we were immediately stoked.
We got the chance to evaluate a brand new chip. Even though still in beta stadium, this motion controller was a perfect match for a CNC machine: It can execute motion commands stand-alone. Set the target for the axis and the controller does the rest. It is able to use constant jerk acceleration profiles. This means it is not only capable of accelerating and decelerating properly. It can even control the acceleration force on the moved object (e.g. extruder). The force slowly increases during acceleration up to an allowed maximum. This gives much more controlled motion profiles and less stress on the mechanical structure. The motion controller can even handle end stop switches or running closed-loop with encoder feedback!

After some beers everything fell very fast into place:

Motion is much easier with motion controllers

We can use high level languages for much easier ‘machine programming’

We can develop the CNC driver board ourselves!

So why not just start and see how far we can get?

The idea of the T-Bone

So how do we combine those motion controllers with some software to get a real different CNC controller?
First of all we want to program the CNC machine (e.g. our RepRap 3D Printer) in a high level language since they are more easy to use. Straight forward thinking was to take a BeagleBone Black and programming it in Python?
The motion controllers are capable of coordinating position, speed, acceleration and deceleration of the stepper motors. Just everything to realize single movement segments. The high level control just needs to calculate various segments and send them serially to the motion controllers.

To feed the motion controllers with the segments requires simultaneous serial real-time communication. We have to send a segment as soon as the previous segment is finished. Using a Linux based system for this is really hard. Of course there is the Programmable Real-time Unit (PRU) in the Beagle Bone – but then again the PRU has to be programmed in assembler. Fortunately there is a really simple to use, real time capable MCU: The Arduino. It can buffer several segments and feed new data in the motion controllers when they finish a segment.

The overall architecture is quite simple:

The CNC control is a Python program in the BeagleBone. It reads G-Code, creates tool paths from it, has a nice web interface and is easy to adapt. The G-Code is split in paths and those paths are planned. Those paths re split into segments and those segments are sent to the Arduino. The python program knows which motion controllers belong to which axis and how to coordinate a motion with several axis.

The Arduino (for prototyping we used an Arduino Leonardo – hence we included an Arduino Leonardo compatible MCU on the T-Bone) gets those segments and sends them to the motion controller. It knows when a motion controller finished a movement and needs new segment data. The only job of the microcontroller is to read segments, buffer them and send them at the appropriate time to the motion controller. No complex logic or hardcore assembler. No matter if the T-Bone controls a CNC mill or a 3D printer. The Arduino program can be almost the same.

The Motion controller move the stepper motors. Nothing more, nothing less. It knows the speed of the motor, the maximum speed, the acceleration profile and generates driving signals for the stepper motor. It can notify the microcontroller when the stepper motor reaches its target position and can directly execute the next movement.

Realizing the T-Bone

After we got the basic architecture we could start to design the final board and software. We literally started prototyping everything on bread board. After some iteration in hard and software we finally could design the first real boards (of course only genuine with fix wires).