Dobby Upgrade for 3D printed Table Loom

History of Dobby looms

The term “dobby” refers to a type of loom that makes it possible to lift several threads at the same time. This technique became popular in the 19th century with the mechanization of looms. Prior to this, the Jacquard loom, invented by Joseph Marie Jacquard in 1804, had controlled the lifting of threads via punched cards and thus revolutionized pattern weaving. The Dobby device built on this technology, but offered a simpler and more cost-effective method of creating complex patterns. Dobby looms were a key part of the industrial revolution and made textile production more efficient and flexible.

The term “dobby” is an abbreviation for “draw boy”. Originally, this term referred to the assistants who manually raised and lowered threads in traditional weaving workshops to create patterns. The Dobby device automated this process, eliminating the need for manual work.

Here you can download the files:

Here you can find the article on the basic loom: Click me

Here you can find my video about the Dobby upgrade: Youtube

If you would like to build my loom, you will find everything you need here: Etsy or Cults3D

Here you can find the Dobby Upgrade: Etsy or Cults3D

I printed the loom with my Bambu Lab printers.
Here you get a top price and support my work.
Bambu Lab A1: A1
Bambu Lab X1C: X1C

Upgrade for the 3D printed loom

As my 3D-printed loom has generated a lot of interest, I have decided to equip it with a dobby jig. Although weaving with the levers basically works perfectly, it requires a lot of concentration to avoid mistakes. I solved this problem by designing a warp to which the weaving pattern is pinned. The upgrade is fully compatible with the basic loom model. Only the upper connecting plates need to be reprinted.

The first step is to choose a weaving pattern that you like. In this article, I explain how to read the pattern correctly. It is relatively easy to transfer the pattern to the warp. I have printed a small tool for this, with which you can easily insert and remove the pins. Depending on the number of sequences in the weaving pattern, a corresponding number of chain links are required. A pin inserted in a chain link activates the corresponding shank, which then lifts the corresponding threads.

The bolts push the lifting mechanism of the individual shafts slightly to one side.
The so-called blade is lifted by means of a lever that is operated by hand, which in turn lifts the activated shafts.

Basically, there’s nothing else to mention. It’s best to watch my video about it. It clearly explains how it works and you can understand the process much better.

E-Dobby Table Loom

The mechanical dobby upgrade with warp has a small disadvantage: the length of the warp is limited, which means that you can only weave sequences of around 40-50 different settings. This system reaches its limits with more complex and longer patterns. For this reason, I have extended the basic model of the 3D-printed loom with an Arduino. This means that there are no longer any limits to the creativity and complexity of the patterns. The E-Dobby loom is easy to program, which means that even extremely long sequences are possible without any problems.

To equip your 3D printed loom with an Arduino, you need the basic model and the Dobby upgrade for the loom.
You can download the Arduino upgrade for free.
You can find the base model here: Etsy, Cults3D
Here you can find the Dobby Upgrade: Etsy, Cults3D
Arduino E-Dobby Upgrade: Thingiverse, Printables, Cults3D

How it works

I opted for a solution with solenoids, as these offer an inexpensive and simple way of activating the individual shafts. However, there were a few problems: After just a few seconds in operation, the solenoids get so hot that you can no longer touch them. Over time, they even start to smell and eventually break.

The solution to the temperature problem consists of several approaches. Physically, I have equipped the solenoids with heat sinks that are additionally cooled by computer fans. On the software side, each solenoid is monitored to ensure that it receives at least 10 seconds of cooling time. The last switch-off time of each solenoid is stored and it is continuously checked whether enough time has passed before a solenoid can be reactivated. This combination of heat sinks, fans and a software-controlled cool-down time ensures that the magnets remain well cooled and do not overheat.

The solenoids are controlled using an Arduino Nano and MOSFET modules. A 12V power supply unit is required for the power supply. A 1.8-inch TFT display shows all the important information – more on this later. The cables for the magnets and fans are routed from the right-hand side of the loom to the back and then to the left-hand side, towards the Arduino and MOSFET modules, and fixed in place with cable ties. The MOSFET modules are connected in sequence and pushed into the loom.

The wiring of the entire system is relatively simple. Although a large number of cables come together, it should not be a major problem if you carry out the wiring step by step. With a structured approach, everything remains clear and easy to handle.

An electronic Dobby loom would be difficult to operate without visual feedback. That’s why I installed a 1.8-inch TFT display that shows all the important information needed for operation. This means you always have an overview and can control the weaving process efficiently.

The following information is shown on the display:

The following information is shown on the 1.8-inch TFT display:

Sequence: Displays the current sequence of the weaving sequence.
Cooldown: Shows the remaining seconds until the next dobby pattern can be activated to ensure the cooling time of the magnets.
Next: The next sequence is activated with the green button.
Back: The red button can be used to switch back to the previous sequence.
Save/Load: The yellow button can be used to save the current sequence or load a saved sequence. As a weaving project often lasts several days, it is important to save the sequence before switching off the loom. When you switch it on again, you can load the sequence and continue exactly where you left off. The sequence is saved in the EEPROM of the Arduino. The logic works in such a way that the old sequence can be loaded after a restart, and after the shafts have been activated once, only saving is possible.
Weft Color: The background of the display shows the color of the current weft thread, so that the planning of the weft threads is precise in terms of color.
Upper and lower stripes: The color of these stripes indicates whether the next sequence can be activated. Green means that the next sequence can be continued, while red indicates that a cooling time is still required.

Arduino Code

Of course, a lot of code is required for all this to work. Here I show you how you can integrate a web pattern directly into the code. Currently this is still done manually in the code itself. In the future, however, I plan to add the ability to directly read a .wif file (a common file format for web patterns) and automatically transfer the parameters into the code.

To understand the basics of reading a weaving pattern, please take a look at this article: 3D printed Table Loom

I am using a simple web pattern as an example here:

So, how is the loom programmed? Let’s take a closer look at the Arduino code. There are a few variables that need to be configured.

This part of the code shows the connections of the individual shafts. It shows which heald frames are to be lifted together. This information can be found in the weaving pattern in the field at the top right.

For this pattern, the binding must look like this:


int anschnuerung[maxAnschnuerungen][numShafts] = {
  {1, 0, 1, 1, 1, 0, 0, 0},  // Tension 0
  {1, 1, 0, 1, 0, 0, 0, 1},  // Tension 1
  {0, 1, 1, 0, 0, 0, 1, 1},  // Tension 2
  {1, 1, 0, 0, 0, 1, 1, 0},  // Tension 3
  {1, 0, 0, 0, 1, 0, 1, 1},  // Tension 4
  {0, 0, 0, 1, 1, 1, 0, 1},  // Tension 5
  {0, 0, 1, 1, 0, 1, 1, 0},  // Tension 6
  {0, 1, 1, 0, 1, 1, 0, 0},  // Tension 7
  // Add more tensions here up to 50...
};

Next, the sequences must be entered. This means the order in which the shafts are to be activated. In this example, it looks like this:


// Define and initialize sequences
int sequenz[] = {1,2,3,4,5,6,7}; // Enter sequences here (First tension starts at 0!!!!!)

If you have very long sequences, the easiest way is to get a .WIF file. Then look for the “Treadling” section in the .WIF file. This is the required order of the sequences. Open ChatGPT.com and enter the following sentence: “Delete all numbers before the = sign. Write them down in this format: …,…,…,…,…,…, etc. Here is the list:”
Then copy the list of sequences from the .WIF file. ChatGPT will then give you the complete sequence order, which can be copied directly into the Arduino code.

The last parameter to be defined is the color of the weft yarns. The respective color must be defined for each weft. The colors are entered with numbers according to the table. For our example, this would mean the following:


/ Define and initialize colors
int color[] = {4,4,4,4,0,0,0}; // Enter colors here
// 1 for Blue
// 2 for Red
// 3 for Green
// 4 for White
// 5 for Yellow
// 6 for Cyan
// 7 for Magenta
// 8 for Black
// 9 for Orange
// 0 for Purple

Logically, it is important to ensure that the number of sequences and the number of colors entered are the same. In our case, there are 8 sequences and each sequence is assigned a color.

The entire configuration for this simple pattern looks like this:


// Here the web pattern is entered 
// Tensions (each tension activates different shafts)
int anschnuerung[maxAnschnuerungen][numShafts] = {
  {1, 0, 1, 1, 1, 0, 0, 0},  // Binding 1
  {1, 1, 0, 1, 0, 0, 0, 1},  // Binding 2
  {0, 1, 1, 0, 0, 0, 1, 1},  // Binding 3
  {1, 1, 0, 0, 0, 1, 1, 0},  // Binding 4
  {1, 0, 0, 0, 1, 0, 1, 1},  // Binding 5
  {0, 0, 0, 1, 1, 1, 0, 1},  // Binding 6
  {0, 0, 1, 1, 0, 1, 1, 0},  // Binding 7
  {0, 1, 1, 0, 1, 1, 0, 0},  // Binding 8
  // Add more tensions here up to 50...
};

// Define and initialize sequences
int sequenz[] = {1,2,3,4,5,6,7}; // Enter sequences here (First tension starts at 1!!!!!)

// Define and initialize colors
int color[] = {4,4,4,4,0,0,0,0}; // Enter colors here
// 1 for Blue
// 2 for Red
// 3 for Green
// 4 for White
// 5 for Yellow
// 6 for Cyan
// 7 for Magenta
// 8 for Black
// 9 for Orange
// 0 for Purple

// End of input

With a little trial and error, you will quickly understand how the logic behind it works. That’s all you really need to do. You can therefore create a library of patterns and simply insert them into the code to weave them.