The T-bone is a cape for the BeagleBone Black, dedicated for motion control application. These are 3D printers, laser cutters, milling machines, and other applications using stepper motors. The software will be able to control at least one type of 3D-printer and will mainly use well-known open source components. So everybody can adapt it to it’s own requirements.
To join highest performance with flexibility and easy programming, we introduce a very powerful concept: Hard- and software abstraction layers! User interface, configuration, and path planner are running at the BeagleBone. This makes it easy to use existing open source software components like slic3r, using the existing toolchain and OS of the BeagleBone. Real-time communication with the BeagleBone is handled by a small micro controller, placed on the T-bone. The micro controller is is fully Arduino compatible and can be used with the Arduino toolchain, so everybody can easily modify it. Complex acceleration and velocity calculations for the stepper motors are done by dedicated motion controllers. These are dedicated hardware components, developed to get the maximum performance out of a given stepper motor without putting any workload to the host system. The various abstraction layers ensure that each part is most simple to understand, adapt and extend.
Here are the main features of the basic board:
- 5 stepper motor driver
- 10 inputs for end switches
- 3 inputs for incremental encoders (3 axis supporting closed loop control)
- 3 inputs for thermistors
- 1-wire interface for digital tempsensors
- 2 high power outputs (for extruder and heatbed)
- 2 mid power output (for fans, LEDs, …)
But that’s not all. We are planning to create some additional expansion boards with special features. Here are some of the feature we are planning:
- Support for rotary axis like driller, miller, …
- Support for laser cutters
- External touch panel display
- Support for other hardware plattforms (e.g. Arduino TRE, Arduino Galileo)
The T-Bone is using a smart and proven concept for improvement and simplification at the same time: division of work. dedicated motion control units are executing lowlevel, but time-critical functions. The BeagleBone can concentrate on complex tasks and user interfacing. Both parts are connected by an Arduino-compatible microcontroller, decoupling high-level and real-time programming.
The connection between the two board is realiued by a asychronous UART interface. It’s easy accessable in software, offers high data rates, and decouples the task-driven BeagleBone and the real-time operation of the T-bone.
A more detailed view to the hardware structure (for more detailed hardware description see here):
Abstraction is the #1 concept for good software design. The T-Bone software separates high-level logic from realtime tasks, very hardware-specific routines from the almost infinite world of user interfaces.
Let’s take a short look inside the different software layers our system:
1. Layer, Interfaces: All 3D printers need to have an interface for general setup, receiving jobs, status reports. They can be connected to a host PC or operating standalone. Therfore they need to offer certain interfaces like USB, LAN, WLAN, SDCard, LCD-controllers or touch screens. With the Linux-running BeagleBone most of these interfaces are already available or easy to realize. The T-Bone will come with a simple to use web interface. The web interface is based on Python and Flask — since this is easy to adapt and extend.
2. Layer, High-Level Control: A printer usually receives jobs in G-Code, a high-level script language telling the printer what to do. The G-code is translated into movement commands for the axis and the extruder. A pathplanner optimizes the movements of several printing segments. Heaters, fans, and other tools of the printer are controlled by service processes. With the T-bone, all these tasks can be implemented in high-level programming languages like Phython.
3- Layer, Real-time interface: Tightly timed control can be a very challenging task for Linux systems and high level languages. Hence the T-bone incorporates an Arduino compatible micro controller for time critical control. BeagleBone and T-bone are connected by a UART interface. This is an asyncronous bus with high data rates. It’s accessable with standard services of the BeagleBones Linux and the Arduino firmware. The communication is done by datagrams, buffered in the UART-interface of each controller. The T-bone controller buffers several motion commands from the BeagleBone. The idea is to offer an open interface for all kind of projects using stepper motors or other kind of actuators.
4. Layer, Real-time hardware control: Controlling a stepper motor is a challenging job. For every movement a sequence of single steps is created, accelerating to maximum velocity and decellerating to the target position. And it’s becoming even more challenging if it’s done for several synchronous axis. For the T-bone motion control hardware this is home turf.
The first software the T-Bone comes with is a driver for a RepRap 3D Printer. Not all parts are RepRap specific, but everything for a 3d Printer is there. All software elements are without excpetion open source. Later on the source code will be released on GitHub. Everbody is welcome to join our development team. Want to add support for your own project or a special kind of application? Just let us know! We will also release a documentation of the interfaces and software structure of different layers.
The board is in total 158.5 x 185.5 mm². It has six holes, four are on the same places like on the BeagleBone. Two additional holes are in line with two of these holes. The distance between the BBB-holes and the additional ones is not 100% fixed now.by