TMC2208 UART on BigTreeTech/BIQU SKR V1.1 and V1.3 Controllers




So.. You got yourself a BigTreeTech/BIQU SKR board, and you wanna use TMC2208 driver modules on it, in UART mode, with Marlin? Pretty simple really.

Prerequisites, SKR v1.1 only:

  • some female Dupont connectors (two per driver module). These connectors are easily found in many kinds of electronics - I salvaged the ones I use from old PC cases. You likely already have some in your junk box. Er, you DO have a junk box, right? :-)
  • some appropriately-sized wire (these are just signal lines we're dealing with, so just about any size will do as long as it works and is easy to handle)
  • some 1/8 inch or 3 mm heat shrink tubing (I use 3:1 shrink ratio).
  • you'll need to know how to do a little basic soldering.

Prerequisites, SKR v1.3 only:

  • Several shunt jumpers.

For both: You must have Marlin from the "bugfix-2.0.x" git branch, from roughly March 1, 2019 (or later). You may not necessarily be able to just use any random download/snapshot, so best if you get it from git:

git clone
cd Marlin
git checkout bugfix-2.0.x

That'll put you at the very tip/HEAD of the repository. If you find that it doesn't work for you (perhaps due to a bug, it is under active development, after all), git reset --hard d8329d85 will put you at a known, working point (I was at commit 2513f6b5 when this Instructable went live).

Your PlatformIO software serial library must be at v0.1.0 or later. Atom users: if you click on the "PlatformIO" menu, and select "Update platforms, packages and libraries", that'll do the trick (other IDEs with PlatformIO support should have a menu somewhere that's not entirely unlike this).

Once you're sure your Marlin and PlatformIO are ready, go ahead and load your Marlin configs into Atom or whatever IDE you use.

You'll want to have good lighting, and a magnifying glass (or a decent magnifier lamp).

If you have an LCD connected, please disconnect it prior to following this guide, just to avoid any possible interference. You can plug it back in later.

You may find that the LCD itself works fine once plugged back in, without any additional configuration beyond what it "should" need, but plugging an SD card into the LCD's card reader may cause things to go awry. This would be because the LCD's SD card reader uses GPIO lines that conflict with the ones the 2208's use (per this guide anyway).

The SKR's onboard SD card slot works fine and does not conflict with the 2208's, so if worse comes to worst, you could just use its reader instead of the LCD's.

Some pins that may work to drive the 2208s' UART lines in lieu of the ones given later in this guide include whichever endstop lines are unused on your setup (the six lines are P1_24 through P1_29), or the TX pin on AUX1 (P0_02). Gloomyandy did have this last one configured to drive a 2208 running a second extruder in his original pins definitions (though commented-out). There may be other pins on the LCD/SD/SPI header that can be safely shared with the LCD or its SD reader. I have not tested any of these, so comments welcome.

I'll leave it as an exercise to the reader to choose appropriate GPIO pins for the 2208's to keep them and the LCD and/or its SD reader out of each others' way.

Step 1: Modify Your Driver Modules (v1.0 Modules, Bottom Side)

I use Eryone driver modules (the amber board above), which are basically the same as FYCETC modules, PCB color aside. On those brands, and on many others, there are two sets of jumper pads on the underside: one close the STEP pin (right next to a resistor), and one close to the middle two pins, of the EN/STEP/DIR header.

On some brands of driver modules, there may be three sets of jumper pads.

In all cases, we're interested only in the set of pads near the middle of the header. Use your soldering iron to bridge this middle pair of pads together. This will connect the driver chip's PDN/UART line to the PDN pin on the module's header.

On some TMC2208 modules, the chip and various other parts are on the top of the PCB, instead of the bottom like usual (the black PCB pictured above). If you have this kind, then if you hold the module with the chip and such facing you, and the potentiometer and test holes to your left, there'll be one set of jumper pads on the right, next to a resistor, and one set near the middle. There may also be one set on the left. Again, the middle jumper is the one you want to bridge.

There are at least two brands that put the chip and such on top (Watterott and BigTreeTech).

Note: some brands of modules may say "v2.0", and still have a two-pad jumper. Treat these like the v1.0 modules, for the purposes of this Instructable.

Step 2: Modify Your Driver Modules (v1.2 Modules)

In some newer TMC2208 driver modules, this middle jumper has a set of three pads. If you hold the module with the bottom facing you, and the potentiometer and test holes to your right, the middle and right pads of this jumper are the ones you're interested in.

Bridging those pads together connects the driver chip's PDN/UART line to the otherwise-unused pin on the module's EN/STEP/DIR header. You should remove any connection there may be between the middle and left pads. It won't hurt anything, we just want to avoid confusion.

If you have one of the parts-on-top driver modules mentioned earlier, but with a three pad jumper, then holding the driver with the top facing you, and the test holes and potentiometer to the left, it'll most likely be the middle and left pads that you need to bridge. I have yet to find an example of this type of everything-on-top, three-pad jumper driver module. I'm sure they exist, or will soon enough (since the two-pad jumper is the older version).

On the SKR v1.3, your board already has all the internal wiring needed, and Marlin already has appropriate pins defined for it. You just need to plug in the necessary shunts, as directed in the SKR v1.3 user manual.

If you're using three-pad-jumper driver modules, or if you are using an SKR v1.3, skip ahead to "Step 6: Give your board some intelligence".

Step 3: Modify Your Driver Modules (v1.0 Modules, Top Side)

If your driver module is of the type with two pads on the middle jumper, then you will need to make a solder bridge on the top side to connect PDN to the unused pin next to it on the EN/STEP/DIR row. This unused pin is most likely unmarked, or may be labeled "NC". On my Eryone modules, the manufacturer put the OpenHardware logo next to it.

Step 4: Patch Things Up

You'll need to prepare some simple patch wires, with a female Dupont connector on each end.

Affix the the plastic connector housing to only one end -- leave the other connector bare. Carefully bend that bare one in half backwards, to create a simple right-angle connection (by "backwards", I mean that once bent, you could put a really long pin through the connector part, without hitting the crimped end). Add a drop of solder to the inside of the bend to reinforce it, and shrink a bit of heat-shrink tubing over it for insulation.

For whichever axis you're working on, remove any shunts from the board's MS1-MS3 config jumper block. Connect the "right-angle" end of one of these patch wires to pin 5 of the block (it should be clearly marked on the board next to the pin). This would normally be the MS3 signal line on drivers like the A4988, but TMC2208 driver modules don't use this connection at all, so the soldering we did on the module rerouted the UART signal so that we could pick it up from this pin. Connect the other end of this wire to an appropriate GPIO pin on the SKR's AUX1 or AUX3 header. But just where are these signals? That's explained in the next step! :-)

Step 5: Help Marlin Make the Connection

You will need to define some pins to match where you connected the patch wires on AUX1/AUX3. But, there are a few more pins available on the board than you'll need for this project, so you have some leeway here.

This "leeway" can be confusing, though (it didn't do me any favors, to be sure), so to make it simple, I went with gloomyandy's pins definitions, and put the following into src/pins/pins_BIQU_SKR_V1.1.h just before the temperature sensor pins:

  #define X_SERIAL_TX_PIN    P2_06 // on AUX2, "2.6" on the board and pinouts image
  #define X_SERIAL_RX_PIN    P2_06
  #define Y_SERIAL_TX_PIN    P1_31 // on AUX2
  #define Y_SERIAL_RX_PIN    P1_31
  #define Z_SERIAL_TX_PIN    P1_23 // on AUX2
  #define Z_SERIAL_RX_PIN    P1_23
  #define E0_SERIAL_TX_PIN   P0_03 // AUX1 "RX"
  #define E0_SERIAL_RX_PIN   P0_03

Step 6: Give Your Board Some Intelligence

You will of course need to configure Marlin to build for and run on the SKR if you have not done so already. For brevity, I've omitted most settings that are commented-out or are either specific to my bot alone, or which don't apply to my bot at all. That is, I've tried to include only the stuff that everyone will need. Here are the basic settings for Configuration.h:

#define SERIAL_PORT -1
//#define SERIAL_PORT_2 -1

#define BAUDRATE 250000


Plus whatever other configuration you need for your printer, i.e. thermistor type, temperature limits, motor steps/mm, speed and acceleration limits, build volume, end stops, and so on. Regarding the baud rate, you can use whatever baud rate you want that works with your PC/OS, from the list of suggestions just above that option in the config. Faster is better, up to a point (I bumped it up to 500 k after writing this guide).

Step 7: Configure Marlin for Your Driver Modules

Set Marlin up for TMC2208 regular mode (not "STANDALONE") for whichever axes use them (I have all four), with appropriate settings for current, microstepping, stealthChop, spreadCycle, or Hybrid mode, and so on.

For example, in Configuration.h, I have these settings:

#define X_DRIVER_TYPE  TMC2208
#define Y_DRIVER_TYPE  TMC2208
#define Z_DRIVER_TYPE  TMC2208
#define E0_DRIVER_TYPE TMC2208

...and in Configuration_adv.h, I have these, in various places as appropriate for that config file:

#define MINIMUM_STEPPER_PULSE 1   // 0 is not recommended for TMC2208 anymore.
  #define HOLD_MULTIPLIER    0.5  // Scales down the holding current from run current
  #define INTERPOLATE       true  // Interpolate X/Y/Z_MICROSTEPS to 256

  #if AXIS_IS_TMC(X)
    #define X_CURRENT     600  // (mA) RMS current. Multiply by 1.414 for peak current.
    #define X_MICROSTEPS   16  // 0..256
    #define X_RSENSE     0.11

  #if AXIS_IS_TMC(Y)
    #define Y_CURRENT     600
    #define Y_MICROSTEPS   16
    #define Y_RSENSE     0.11

  #if AXIS_IS_TMC(Z)
    #define Z_CURRENT     800
    #define Z_MICROSTEPS   16
    #define Z_RSENSE     0.11

  #if AXIS_IS_TMC(E0)
    #define E0_CURRENT    500
    #define E0_MICROSTEPS  16
    #define E0_RSENSE    0.11
  //#define STEALTHCHOP_E
  #define X_HYBRID_THRESHOLD     150  // [mm/s]
  #define Y_HYBRID_THRESHOLD     150
  #define Z_HYBRID_THRESHOLD       3
  #define E0_HYBRID_THRESHOLD     10
#define TMC_DEBUG

Step 8: Finishing-up

Install the driver modules onto their headers.

Set the SKR's power jumper to USB mode, hook up your USB cable, and compile and upload the firmware.

You should now be done with the basic configuration.

Time to power-down, wire-up your printer's main 12/24v power supply, motors, end stops, heaters, sensors, etc., move the SKR's power jumper to "INT", and power back up. Check that your motors work, and run in the right directions.

At this point, you should also adjust the driver modules' potentiometers to set fallback currents in case the UART feature craps out.

You may now begin routine calibrating and printing.

Enjoy your 32-bit goodness! :-)

Step 9: Credits and Notes

  • This Instructable was inspired by "UART This!" by seansadler.
  • jammi clued me in to the UART-on-MS3 method via his RAMPS-oriented imgur guide, sure beats unsoldering and/or flipping pins around!
  • The drawing of the pinouts of the SKR v1.1 came from BigTreeTech's public Github repository, modified by me.
  • The photo of the TMC2208 module with three-pad PDN/UART jumper was cribbed from an Aliexpress listing, enhanced and modified by me.
  • The photo of the TMC2208 module with everything on the top side of the PCB was "borrowed" from a Github thread, enhanced and modified by me.

Try as I might, I could not find a single, clean, obviously-free-license image of those two kinds of driver modules, so I'm gonna have to claim "fair use" on both. :-)

About connector and wire colors:

Shortly after I got my SKR, I killed it by accident while probing around on it. But a while before that happened, I swapped the motor and endstop connectors around so that X is red, Y is green, and Z is blue, to match what you see in most 3d modeling programs, then color-coded my patch wires to match. Since I still have that board in my junk box, I just went ahead and used it for most photos, just so that I didn't have to pull my good, working board out of the printer. The white patch wire seen in some photos is just an extra I had lying around.

The working board is shown in the final image since since I needed a "complete, installed" photo at that point, and while it has "correct" wire colors, it has "incorrect" connector colors. My OCD isn't quite triggered enough to overcome my laziness. ;-)



    • Trash to Treasure

      Trash to Treasure
    • Tape Contest

      Tape Contest
    • Arduino Contest 2019

      Arduino Contest 2019

    4 Discussions


    Question 8 days ago on Step 3

    So in order to use the eryone 2208 on a skr 1.3 I have to solder the pads on the bottom and the pins on the top as well?

    1 answer

    Reply 7 days ago

    With SKR v1.3, you only need to close the two pads on that tiny jumper on the bottom of the module (well it's usually on the bottom anyway :-P ). This connects the driver chip's UART signal to the PDN pin on the driver module.

    You don't have to solder the two pins together on top of the module, as the SKR v1.3 already has the internal wiring to pick up the UART signal directly from that PDN pin. Soldering the two pins together is only to route the driver module's UART signal to the MS3 pin for convenience, which is what those custom patch wires are for. It won't hurt anything if they're soldered together anyway.

    If I understand it correctly, you just put shunts on the red two-pin UART headers next to the driver modules, instead.


    5 weeks ago

    Thank you for sharing your first instructable! : )

    1 reply

    Reply 4 weeks ago

    You're quite welcome. I hope it helps a few people get up and running. :-)