Trinamic TMC2300 EVAL KIT (2-PH Stepper Motor) - Review

Table of contents

RoadTest: Trinamic TMC2300 EVAL KIT (2-PH Stepper Motor)

Author: pedfer

Creation date: 18 Feb 2020

Evaluation Type: Development Boards & Tools

Did you receive all parts the manufacturer stated would be included in the package?: True

What other parts do you consider comparable to this product?:

What were the biggest problems encountered?: Getting the basic "tests" with the IDE passing

Detailed Review:

Welcome to this RoadTest review of the Trinamic TMC2300 Evaluation Kit.

This is my first RoadTest, so please let me know any suggestion or improvement that you consider!

Firstly, thanks to Jan Cumps and Workshopshed who are also roadtester of the TMC2300 Eval Kit and who kindly helped me and shared their results at early stages.

0. My goals

My aim is to analyze the product as a whole. The quality of the provided hardware and software, including firmware, IDE, etc. Afterwards, I will try to implement a prototype and see how easy it is, and how much time it requires. Are these boards good for prototyping serious designs and comercial products? What about hobbies/DIY projects?

1. The Hardware

This is what I received on the package:

(By the way, this is probably the best and safest packaging I have received in years, I don't know if it's specific for the roadtest or every Trinamic customer as well, but really appreciated).

• x1 Stepper Motor
• x1 TMC2300 Evaluation Board
• x1 Landungsbruecke Board
• x1 Bridge Board
• x1 USB-Type C cable
• x1 Power supply connector

   Landungsbruecke board, which contains the MCU to communicate with the TMC2300

   Bridge Board to connect TMC2300 with the Landungsbruecke

   TMC2300 with stepper motor plugged.

The manufacturing quality of the PCBs of every board is excellent.  And having available datasheets and cad files for the TCM2300 here allowed me to learn about the boards' internals, as well as debugging problems.

Regarding the Landungsbruecke, I could find the appropriate firmware downloads, schematics and PCB drawings here.

2. Hello World TMC2300

This was probably the most time-consuming task of my early attempts at getting the board to work. This was likely my fault, having not initially understood properly how the different registers influence the  and how the Trinamic IDE Software automatically configured the IC and instructed it, in summary, how it interacted with the board behind the scenes.

For this "hello world" demonstration (using the IDE to move the motor and see how it behaved) I followed the User Manual trying to test some of the evaluation features in the TMCL-IDE but the main goal was to get the provided motor rotating and to test the options in the IDE.

Firstly I set up the Trinamic IDE on my Linux Mint laptop. The IDE GUI in linux runs incredibly fluent, but depending on the configuration of your distribution or system, you may need to run the whole software as root, or at least an elevated user, to have access to the USB(uart) ports and communicate with the board. Otherwise the IDE will refuse to detect any board.

Unfortunately, even though I replicated most of the steps that I followed as well in Windows, you will see I wasn't able to achieve a basic IDE-controlled movement of the motor. So for the rest of the review, I continued to use a Windows computer.

Additionally, I have found a little bug on the Linux version, which appears when the IDE tries to auto-detect which board we have plugged. When the Safety Notice dialog appears:

Clicking "OK" will trigger the board detection again, thus, making the Safety Notice dialog appear another time, and it will keep like that until you press the "X" button, which actually makes the configuration stay, and you are ready to use the board in Linux. I have not found this issue in Windows 10.

I then proceeded to set up a 1Amp 5Volts power supply. Even though the provided motor is a 3.3v motor, according to the Trinamic FAQ (motors section):

"Stepper motors are designed to work this way and it is safe to run the motors at up to 20 times the rated voltage. You will actually get much better performance by running at a higher voltage than the rated voltage."

So, I decided to give it a try, as well as an 11v power supply and a pair of AA batteries. Neither of these supplies seemed to be detected by the IDE, which reported 0v/insufficient supply. And of course the motor wouldn't work.

Fortunately, after performing several board resets ("Reset boards to defaults" button) the TMC2300 started responding and I was able to do the basic operations like driving the motor speed, rotating, stepping, accelerating, etc. Despite this, the error shown above "No or too low motor supply detected" did not disappear.  

3. Prototyping. Can I set up an assisted camera movement using the TMC2300?

My question was the following: would I be able to set up a working prototype of a system that used the Eval board and motor capabilities? and most importantly, how much time would it take? Quickly, I looked for extra hardware I could have lying around in the lab and tried to come up with an idea of something reliable. Ideally, it had to use the Landungsbruecke so I could put to work all the hardware that I had been provided, but I'll get into more detail later about the uses of the boards separately.

Luckily I found some nice gadgets that could be useful: A Raspberry Pi B+, a no-IR camera for the Raspberry, some basic materials for prototyping (wood, cardboard, and the usual tools). And the idea came up. Get the camera running and streaming, control its movement with the stepper motor and the TMC2300.

   Some of the extra devices I used for this prototype example.

After that I was ready to try and discover how much effort this supposed.

I crafted a flat stand where I could place the Raspberry Pi and attached it to the stepper motor. Got the motor connected to the TCM2300 and the Raspberry placed atop of it.

Honestly, it took me more time to set up a new microSD card for the raspberry than it took to configure the Trinamic IDE, boards, and supply, which goes to show.

After having a raspbian OS running on the board, everything else was straightforward and took me just a couple of minutes:

The Software

On the raspi side, I just needed to activate the camera driver (for old raspberry versions, this is not required on raspberry 3 or newer for example) and get the live video using:

On the TMC2300 side, I decided to use the IDE with the Landungsbruecke board in order to find how viable this was. Power supply connected, firstly trying with the AA batteries. USB type C connected to my Windows computer.

  Velocity mode working as expected.

   Full rotation test of the motor with the Raspberry.

It was clear that the hardware was totally capable so I decided to put everything together. It is notable, that the sound produced by the motor is null, likely due to the StealthChop feature.

This was a quick testing prototype of the camera working and being controlled with the Trinamic board while I checked the correctness of the video output:

   In the meanwhile, my battery adapter broke so I had to connect the batteries "baremetal".

Even though the current setup was just for demonstration purposes, it can be quite easily turned into a proper portable, battery-powered device, as the TMC2300 is oriented to be used with batteries. I would like to extend the concept in order to make a remote, operable camera.

This is really feasible, as the TMC2300 has a new mode, the UART STEP/DIR mode with Full Diagnostics and Control. This is great as it makes the board controllable by other MCU's. Other roadtesters are indeed using different boards than the provided Landungsbruecke, which gives me confidence to believe even the raspberry could control the TMC2300 and handle the movement of the motor without issue.

4. Landungsbruecke IC

A quick search in Github showed that there exists user-made libraries and programs to control the other different Trinamic Driver boards available in the market, using hardware like Arduino. And apparently alternative MCU's can also be programmed to communicate with the board. Definitely, the Raspberry Pi could do it too. Therefore, I decided to move on and not focus my efforts on the driver board, but on the Landungsbruecke board, and discover how flexible and powerful it could be, as it was now clear that the TMC2300 is a quite versatile board and could be used with other components. Is this true for the Landungsbruecke as well?

My aim was to be able to compile the provided firmware and be able to extend its functionality.

The main repository for the firmware can be found here: https://github.com/trinamic/TMC-EvalSystem

We will need an environment with the arm-none-eabi crosscompiler installed. In my case, I already had it instaled in my Windows Linux Subsystem (WLS), specifically I used devkitARM for Linux, but there exists a variety of other packages.

Next step is to clone the main repository using git:

git clone https://github.com/trinamic/TMC-EvalSystem.git

Now we have a directory with the source for the firmware. We still need to clone the TMC-API inside the TMC-EvalSystem directory:

cd TMC-EvalSystem
git clone https://github.com/trinamic/TMC-API.git

NOTE: I'm not a git expert, but I am pretty sure there is a way to recursively clone the API repository when cloning the main repository, I believe it is done using the --recursive command line flag.

Next, to specify for which board we want to build, uncomment one line of the Makefile file:

I have uncommented the 6th line, specifying our target device is the Landungsbruecke, and saved the file.

Last but not least, I needed to change the firmware version number of the repository, so the bootloader of the Eval Board would accept the new firmware. To do this, edit main.c and change:

const char *VersionString = MODULE_ID"V308"; // module id and version of the firmware shown in the TMCL-IDE

to

const char *VersionString = MODULE_ID"V107"; // module id and version of the firmware shown in the TMCL-IDE

Finally it's time to compile, executing:

make

To start the compilation.

We can observe that indeed, everything is correctly instructed by the provided Makefile, which targets the cortex-m4 ARM processor of the IC.

In less than a minute (with a very modest PC) the compilation is finished:

We are informed about what sections our binary is composed of.

Under the directory _build_Landunsbruecke/ we have all the output files.

Specifically, the firmware files that can be flashed or that are of interest are:

Where the .hex file is the one that's going to be flashed into the board.

We are ready to flash it into the real hardware using the IDE.

Once the IDE is loaded we need to click the "Firmware Update" label and a new interface will appear. Browse the .hex file using the "Browse" dialog.

If the firmware is correct, clicking the Update button will allow us to flash it into the board's memory.

We can still experience an error, specially the bootloader refusing to accept the firmware because it does not match. This will occur if the VersionString has not been modified.

To sum up, after the successful update, I was able to keep using the board with the IDE correctly and the firmware worked properly.

NOTE 1: The board can enter the bootloader both from the firmware or by shorting the ID_CLK and ID_CH0 pins on start up. This means in case we flash a buggy or bad firmware we won't brick the board, as we can enter in bootloader mode and flash it again.

NOTE 2: I haven't tested it, but apparently the board can also be updated using OpenOCD instead of the IDE (or at least some comments on the Makefile suggest so). This is good because OpenOCD is commonly used for this sort of tasks, is free, and widely documented.

5.Conclusions

I have enjoyed and learned while reviewing and tinkering with the TMC2300 Evaluation Kit. As a whole, it is a fully featured product already, with the addition of open hardware and software that are designed to be extended and modified as you need. Definitely a good bet. Both the TCM2300 and the Landunsbruecke are ready to work together as soon as you unpack them, but as seen can also be used separately with other boards or products, as well as their functionality can be modified as required. This flexibility, in my opinion, makes the product suitable and adequate for almost every project that requires a stepper motor to be controlled with accuracy and eficiency.

Nevertheless, I must say I have not been able to play and work at the low level as much as I would have liked, for example, with functionality like StealthChop or other advanced technologies the Trinamic TCM2300 provides. My overall knowledge on such fields is not much yet, though the IDE has provided an excellent way to test these things and check they worked as promised.

Even though I perhaps lacked a bit of electronics knowledge, I have attempted to present my own progress and results on the product. I hope you find this review useful!