Multi-Shaft Castle for Dobby Loom – 3D Printed and Automated With Arduino Nano

My previously posted Instructable; “Arduino Controlled Fully Automated 3D Printed Tabletop Dobby Loom - Test Prototype” (https://www.instructables.com/Arduino-Controlled-Fully-Automated-3d-Printed-Tabl/) was too complicated! This Instructable describes how to 3D print the central components of a Dobby loom – the castle and associated shafts, heddles and levers, using servo motors instead of stepper motors for automation. I also include an Arduino sketch to operate the mechanism with a PCA9685 Servo Motor Driver IIC Module to simplify wiring. An Excel spreadsheet with a matrix algebra operation to convert a weave draft into shaft commands to produce various twill patterns is also included.

Ardunino Nano and 7v power supply

8ea TS90MD 9g Micro Digital Servo Full Metal Gear 270^o controllable angle motors

1ea PCA9685 Servo Motor Driver IIC Module

8ea 5x11x4mm bearings

1ea push button and 1ea toggle switch

The “castle” on a table loom is the central upright frame or housing unit that holds the shafts (harnesses) and supports the operating levers. This vertical enclosure keeps the heddle shafts stable and aligned as they move up and down to create the shed.

The automated Dobby servo module used to drive levers to raise or lower specific shafts is mounted directly on top of the castle. These pictures show my 3D printed and Arduino automated castle module along with TinkerCad drawings.

This Instructable does not include specifics for the Castle framework. Design considerations such as weave width, number of shafts, and configuration of additional loom components such as the reed, shuttle motion design as well as supply and take-up spools all play a part. The vertical side panels are adjustable to allow heddle shafts to move freely.

My initial design used inexpensive 28BYJ-48 5V Stepper Motors and A4988 Drivers. However, it was slow and connections to an Arduino Mega 2560 required 32 digital outputs for the 8 shaft motors. The elastic return to position was also a bit cumbersome.This design uses small servo motors with rack and pinion coupling to rapidly move the shaft frames to position, as seen in the video. The IIC module requires only 2 pins from the Arduino Nano, making this system efficient and easy to modify for various shaft configurations.

I designed this mechanism around the TS90MD 9g Micro Digital Servo Full Metal Gear with 270 degrees controllable angle. I had previously determined a shed width of 70 mm (2.75 inches) was sufficient to consistently insert the shuttle. The pinion gear is 32 mm diameter to provide approximately 75 mm of rack gear travel for the ¾ turn of the pinion gear. The linear rack gears are each 200 mm long to accommodate this travel distance for the 3 different vertical positions (up, down, center).

These diagrams show the configuration of the guide bars to allow the rack gears to easily move while maintaining good mesh with the pinion gear. At 6.0V running torque of the TS90MD servo motors is approximately 1.4 kg-cm. producing about 0.88 kg of force, quite sufficient to raise a 30 gram (about an ounce) heddle frame and warp threads (the automated design allows slack in the warp threads when producing the shed). Larger servos such as the MG996R could be used to handle wider shaft frames.

This diagram shows the assembly of the servo shaft to drive the pinion gears. The external bars on the shaft allow good drive coupling between the shaft and gear as well as positioning of each pinion when assembling the module. Heat inserts are used hold the components in place. Assembling simply requires rotating the servo to a home position, inserting the rack gear to its home position and inserting the assembled servo shaft into its location. The opposite end of the shaft fits into 5x11x4mm bearings, to maintain alignment and ease of rotation. This assembly is then mounted on top of the castle and a coupling is used to connect each rack gear “lever” to its respective heddle shaft frame. Design specifications of this Dobby mechanism can easily be modified to accommodate different numbers of shafts. STL files for this particular assembly are available if requested.

My first automated loom used what I called a “rigid heddle”, though “fixed heddle shaft frame” more accurately describes the design. I did this to simplify some warp tensioning concerns and make threading the loom easier. However, I quickly discovered the “threading” on a loom requires different configurations of the heddles on the various shafts! I decided to stay with this design as it was quite easy to 3D print stable frames for consistent shed opening. This essentially requires a specific “frame set” for a specified threading. The Dobby servo mechanism is then paired with this design. To change threading simply pull out the coupled frames and Dobby mechanism, replace the frame set with the new one and reinsert into the castle. Of course, new frame sets need to be printed for each threading order.

Locating the heddles in the shaft frame is straight forward in TinkerCad using the duplicate and repeat features. This design uses a spacing of 2.54 mm per heddle or 10 epi (ends per inch). Specific locations of each heddle in the shaft frame is derived from the threading diagram in the weave draft.

Shaft frame thickness is 4 mm and each heddle is 1.4 mm wide to provide sufficient support of the 4.5x8.2mm elongated eyelets. A latch hook easily fit thru this eyelet for double threading cotton thread with a sett of about 12 epi (25 wraps around a ruler divided by 2) to give a balanced plain weave. Wider frames can, of course, be made but may require splicing and reinforcing with metal rod if your 3D printer has a limited print area.

Coupling of each frame to it’s respective rack gear can be done with a simple clip or screw as shown in this design.

The attached Arduino Nano sketch operates the Dobby mechanism using an II2C board to address each servo (up to 16 servos per II2C board).Typically, a weave pik or sequence of one weft thread thru the shed requires the shafts to go to position and then return to a (centered) home position. Additional code would allow specific operator interaction with some type of indicator lights or display prompts. The D_P array numbers in this sketch are interpreted to provide the correct “treadling” for each pik. My earlier Instructable described the Excel conversion of weave draft information (threading, treadling, and tie-up) to a decimal array for a sequence of piks to create the weave product. This method uses a simple copy (from a csv file) into the Arduino sketch. Other methods are certainly available.

There are numerous articles about using matrices to describe weave patterns. I determined to use matrix functions in Excel to display a set of twills and convert to the decimal array required for the Arduino sketch. This Excel file (may open as google sheet) shows one such twill pattern. This file requires manual input of the treadling, threading and tie-up into Excel, but a simple program to read a weave draft for automatic data input could be done, and there are a number of commercial programs that do just that.

https://docs.google.com/spreadsheets/d/1pyElmBDFONCI_N2bI6k855EkZAMB9Dv7/edit?usp=sharing&ouid=115726253944931778740&rtpof=true&sd=true

I found an article by Cally Booker titled “Twills on 8 Shafts: Varying the Treadling” (https://weavingspace.co.uk/twills-on-8-shafts-varying-the-treadling/) that would be a good demonstration of using this automated Dobby mechanism to “vary the treadling”.

These photos (may need to click on) show the same sequence of patterns made using this castle in a single weave.

The Dobby mechanism and associated shafts described in this Instructable might be useful for a variety of loom set ups, including learning the structure of weave drafts with a bit of linear algebra and associated Arduino sketches to automate a specific sequence.