Abstract

Rapid prototyping of interactive textiles is still challenging, since manual skills, several processing steps, and expert knowledge are involved. We present Rapid Iron-On User Interfaces, a novel fabrication approach for empowering designers and makers to enhance fabrics with interactive functionalities. It builds on heat-activated adhesive materials consisting of smart textiles and printed electronics, which can be flexibly ironed onto the fabric to create custom interface functionality. To support rapid fabrication in a sketching-like fashion, we developed a handheld dispenser tool for directly applying continuous functional tapes of desired length as well as discrete patches. We introduce versatile compositions techniques that allow to create complex circuits, utilize commodity textile accessories and sketch custom-shaped I/O modules. We further contribute a comprehensive library of components for input, output, wiring and computing. Three example applications, results from technical experiments as well as expert interviews demonstrate the functionality, versatility and potential of this approach.

Accompanying Research Video

Full video of Rapid Iron On.

In a hurry? We also have a 30-second preview video.

Research Article


Download PDF

Recorded Talk (15 Min.)

Full video of the Talk on Rapid Iron On.

You can also watch our shorter 3 minute presentation from the 2020 Virtual German CHI Week.

Slide Deck

Download Slides (40mb)

Press Material

Press Photos (258 MB)

Publications

Building Instructions

Rapid Iron-On Tool
We first briefly describe the construction of the rapid iron-on tool and list all required components.
Tapes and Patches
Next, we briefly present details for the fabrication of selected tapes and patches.

Rapid Iron-On Tool

Step 1: Prepare the Carriage Model

Required tools:
FDM 3D Printer, sandpaper (extra fine, 600 grit), fine-cut files, screwdriver (slotted), scissor and hobby knife, hacksaw (with metal saw blade).

Partlist for the Rapid Iron-On Tool
Image Part Description
High-temperature ABS Filament
Print temperature: 270°C
ABS can be mechanized, polished, sanded, drilled and glued and the finish is still good. In addition, it is extremely strong, more heat-resistant and it has certain flexibility. All of which makes it the perfect material for the rapid iron-on tool. We used Tiertime UP Fila ABS.
Threaded Inserts
M2*0.4 / M4.5*0.5; 6mm; SKU: GS08040-01
We use threaded inserts to create reusable as well as strong screw connections between different 3D-printed parts (e.g., between the carriage and the spring-loaded iron) of the rapid iron-on tool. Available, for example, on Amazon.
Washer
d1=10.5mm; d2=25mm; s=1.3mm
We placed a washer in the spring-loaded carriage to guarantee that the hot iron shaft never could have direct contact to the 3D-printed plastic carriage. Since the space inside the carriage is very limited, you also have to cut out a rectangle area to place the N20 motor. Washers can be bought at your local hardware store.
Double-sided Tape In order to fix the washer to the carriage model, we used standard double-sided adhesive tape that is available in most crafting shop.
Glass Fabric Tape
PTFE, 25mm x 10m,
heat resistant up to 260°C, self-adhesive
The bonding iron is very hot and in close proximity to the spring-loaded carriage. To add an additional protection layer for accidentally physical contacts of the iron, we partly add glass fabric tape made of polytetrafluoroethylene that is able to temporarily resist heat. For our current prototype, we used this one from Amazon.
Required 3D-printed components
3D Model Description
Carriage Model
carriage.stl

Remove support material and sand the model.

Screw in the four threaded inserts in the carriage model.

Place washer.

Create heat shield.

Step 2: Build RIO Tool Axes

Required tools:
FDM 3D Printer, sandpaper (extra fine, 600 grit), hacksaw (with metal saw blade), fine-cut files, hammer, mini clamps.

Partlist for the Rapid Iron-On Tool
Image Part Description
High-temperature ABS Filament
Print temperature: 270°C
ABS can be mechanized, polished, sanded, drilled and glued and the finish is still good. In addition, it is extremely strong, more heat-resistant and it has certain flexibility. All of which makes it the perfect material for the rapid iron-on tool. We used Tiertime UP Fila ABS.
Bearings
3x6x2.5mm
Available, for example, on Amazon.
Freewheel Bearing
Type: HF0612
dxDxB: 6x10x12mm
In order to tighten the material spools, we used freewheel bearings that can be seamlessly rotated in one direction. A motion in the opposite direction is not possible. This allows us to build a tighting meachnism for the spools. Such freewheel bearings are available, for example, on Ebay.
Brass Tube
Diameter: 6mm
Inside diameter: 5.1mm
The freewheel bearings require a smooth and precise axis that is hard to manufacture with standard FDM 3D-printer. Therefore, we integrated a brass tube that fulfils these properties. Available, for example, at Conrad Electronics.
M2 Screws
l=6mm
M2 screws can be bought in different sizes at many local hardware stores.
Round Bars
Stainless steel,
d=3.00mm
We used the round bars for two purposes: First, both axis of the rapid iron-on tool are made of round bars. In addition, we also use these round bars as guide rails for the spring-loaded mechanism. Therefore we cut the round bar into different pieces of required length with a metal saw and deburred the edges with metal files. Such metal round bars are available, for example, on Ebay.
Timing Belts
Teeth: GT2; Width: 6mm; Length: 200mm, closed
The rapid iron-on tool based on the idea of using timing belts to synchronize the front and back axis. This is important since the iron-on tapes are made of a carrier layer that continuously moves between the axes. Available, for example, on Amazon.
Required 3D-printed components
3D Model Description
Wheel Axis Parts
freewheel_bearing_parts.zip
(recommended version with freewheels and bearings, compatible spool type: I-guide rail)

wheel_bearing_parts.zip
(version with bearings, spool type: U-groove guide)

wheel_parts.zip
(alternative version without bearings, compatible spool types: U-groove guide)

2.1 Axis Part Overview


Both wheel axis are assembled by around 30 parts. The overview shows each part.

2.2 Brass Tube Wheel: Shaft Part (1/3)

  • Cut and deburr the brass tube
  • Place the brass tube into the 3D printed part.
    (If necessary you can carefully use a hammer)
  • Drill two holes in the brass tube.
    >(2mm holes, please align the tube first before drilling)
  • Fix the tube by using two screws.
    (M2, l=6mm)

The brass tube wheel part consists of two outer wheel plates, a timing belt gear, the brass tube itself with two holes, as well as two M2 screws.

2.3 Brass Tube Wheel: Bearing Part (2/3)

  • 3D-print the outer wheel plate
  • Place the mini gear on top
  • Carefully use a hammer to fit the gear into the 3D-printed part

The mini bearing is carefully hammered into wheel cover. Please make sure to do not destroy the bearing by applying to much force.

2.4 Brass Tube Wheel: Assembly (3/3)

  • Glue all three parts
  • Use mini clamps for ensuring good contact
  • Make sure that a 3mm metal axis still fits and did not hit the screws

In order to complete the brass tube wheel you have to glue the shaft part (left), the gear part (middle) and the bearing part (right).

Assemble all parts using press fit. You can also use all-purpose glue to permanently connect all 3D-printed parts of the wheel axes together.

2.5 Opposite Basic Wheel

  • Assembly all parts similar to the brass tube wheel
  • Use one mini gear
  • Use all-purpose glue
  • Mini clamps can be used to ensure good connection

2.6 Freewheel Axis

  • Place and gently press the freewheel bearing into the hole
  • Use a hammer to completely press in the freewheel bearing
    (please make sure that you do not destroy the gear by hammering with too much force. If you need more force use a rubber mallet or tweak the measures of your 3D-printed parts.)
  • Make sure that you consider the correct direction
    (for one pair of axis you have to insert one freewheel bearing with the label to the top and one gear with the label to the bottom.)
  • Swap the axis and gently press mini gear in
  • Use a hammer to completely press in the mini gear.

The freewheel axis is assembled by using three parts: the 3D-printed axis (left), the freewheel bearing (middle), and a mini bearing.

2.7 Axis Assembly

  • Make sure that the basic wheels are connected via a timing belt and the brass tube wheels are connected via a timing belt.
    (Both timing belts should move independently)
  • Check that the freewheel axes could be freely rotated in one direction (without moving the timing belt) to support a fast tightening of the iron-on spools.
    (Each freewheel axis should move in another direction)

Every axis consist of three parts: a basic wheel (left), a freewheel axis (middle), and the tube brass wheel (right).

Finally, assemble the carriage model with the wheel axis by pushing the metal rods inside (left). The assembled model should nicely move (right). If the wheels stuck, please check the friction and proper fit of every involved part.

Step 3: Integration of the Actuated Cutting Blade

Required tools:
FDM 3D Printer, sandpaper (extra fine, 600 grit), fine-cut files, screwdriver (slotted), hacksaw (with metal saw blade), precision side cutter, tweezers, soldering iron (with soldering tin and grease), heat gun (with hook nozzle for shrinking tubing), wire stripper, diamond cutting disc (for cutting hardened steel).

3.1 Circuit Diagram


*While there is currently no easy-to-use Arduino library available that can access the flash memory of the Nordic nRF52832 SoC, we used an external EEPROM to save calibration data.

3.2 Custom Circuit Board

Partlist for the Custom Circuit Board
Image Part Description
RedBear BLE Nano V2
nRF52832 SoC
Bluetooth LE
Arduino compatible
We used the tiny Arduino compatible microcontroller RedBear BLE Nano V2 which based on the nRF52832 SoC. The built-in bluetooth capability allows us to easily configure calibration parameters wireless. While you can also use another micrcontroller (e.g., Arduino Nano 33 BLE), changes in the circuit design, controller housing and program code might be necessary. We ordered the RedBear BLE Nano V2 from Mouser.
Single Brushed DC Motor Driver Carrier
e.g., Pololu MAX14870
In order to control the actuated cutting blade, we need to control the DC motor. Therefore, we integrated the MAX14870 Single Brushed DC Motor Driver Carrier from Pololu that provides us a tiny H-bridge motor driver IC for speed and direction control.
9V Step-Up/Step-Down Voltage Regulator
S10V3F9
The 9V Step-Up/Step-Down Voltage Regulator takes an input voltage from 2.5V to 18V and increases or decreases the voltage to a fixed 9V output. We used this chip to increase the 5V USB or 3.7V LiPo battery to power the motor driver. Available, for example, at Pololu.
Angled JST-Connector
2 contacts, 2mm
To power the motor control board, we used an angled JST-connector that fits most LiPo battery connectors. Available, for example, at Reichelt Elektronik.
Female Pin Headers We used small female pin headers for the prototyping and programming the electrical parts (e.g., microcontroller, motor driver). For the final assembly, we directly soldered all connections to the components in oder to save space. We used tiny female pin headers from Reichelt Electronics.
Prototyping PCB
Phenolic paper
0.1″/2.54mm,
80mm x 52mm, 35µm
We used these prototyping boards as a basis for our circuits. Available, for example, at Conrad Electronics.
Enamelled copper wire
d=0.30mm
To save space, we used enamelled copper wire for the miniaturized version of the motor control circuit. Available, for example, at Conrad Electronics.
Push Button
6mm x 6mm
In order to trigger the actuated cutting blade, we used a 6mm x 6mm tactile push button.
Available, for example, at Mouser.
Miniature Slide Switch
19mm x 5.6mm x 5mm;
Mounting holes 15mm
We used a slide switch to activate or deactivate the power of the circuit. Available, for example, at DigiKey or Mouser Electronics.
LiPo battery
25,5mm x 12,5mm x 6,2mm; 100mAh; 3,7V; JST-PH-Connector (2mm).
In order to provide power to the microcontroller as well as the actuated motor, we integrated a small LiPo battery. If you need longer battery time, you can also choose a larger one or switch to USB power. Available, for example, at EXP-Tech.
I²C EEPROM
Microchip Technology 24LC256-I/P; EEPROM 256 kBit; 32K x 8
While there is currently no easy-to-use Arduino library available that can access the flash memory of the Nordic nRF52832 SoC, we used an external EEPROM to save calibration data. Available, for example, at Conrad Electronics.
10k resistor
Metal film resistor
Axial lead
0.6W
We used two 10k resistor to connect the external EEPROM (see circuit diagram). Available, for example, at Conrad Electronics.
Put a test setup together
First, we recommend to test the circuit with pin connectors to ensure that every component works as expected and you did not have to change connections for the final circuit.Miniaturizing and soldering the circuit board
Next, the circuit needs to be miniaturized by placing and soldering all components on a prototyping PCB. To optimize spacings, we used enamelled copper wire, arrange some components above each other and break out the most important pins (programming interface, power, motor).


Test environment with pin connectors to check the functionality of the circuit and components.


Miniaturized version of the circuit (left: top view; right: bottom view). The external DAPLink programmer is not shown since the programmer is not a part of the circuit and only required for initial programming.

3.3 Housing

In the following, we build a housing for the electronics that can be seamlessly attached to the Rapid Iron-On Tool.

Partlist for the Rapid Iron-On Tool
Image Part Description
3D-Printer Filament We used black Tiertime UP Fila ABS to 3D-print a small housing for the custom motor control board. Of course you can also use any other filament.
Threaded Inserts
M2*0.4 / M4.5*0.5; 6mm; SKU: GS08040-01
We use threaded inserts to create reusable as well as strong screw connections between different 3D-printed parts (e.g., between the carriage and the spring-loaded iron) of the rapid iron-on tool. Available, for example, on Amazon.
M2 Screws
l=6mm
We used two M2 screws with a length of 6mm to mount the SPDT slide switch to the 3D-printed housing. M2 screws can be bought in different sizes at many local hardware stores.
Nuts
M2
We used two M2 nuts to tighten the screws that hold the SPDT slide switch in place. Nuts for metric screws can be bought in different sizes at many local hardware stores.
Optical fiber cable
d=0.03″/0.75mm
We used an optical fiber cable to make the built-in LEDs visible in the housing. Available, for example, at Amazon.
Required 3D-printed components
3D Model Description
Motor Control Housing
Motor_Control_Housing-Top.stl
Motor_Control_Housing-Bottom.stl
Motor_Control_Housing-Button.stl

3.4 Programming

Partlist for programming
Image Part Description
3D-Printer Filament We used black Tiertime UP Fila ABS to 3D-print a small housing for the DAPLink programmer. Of course you can also use any other filament.
DAPLink Programmer
e.g., RedBearLab DAPLink v1.5
The microcontroller did not have a built-in USB programming interface due to the space-saving form factor. Therefore, we used an external DAPLink Programmer that we just need for an initial programming since all calibration and control data can be accessed later via bluetooth. We used the RedBearLab DAPLink v1.5 that is part of the RedBearLab starter kit. We ordered the kit from Mouser.
Highflex Cable
0.05mm²; PVC 0.8mm;
10×0.08mm
Since we have no components that require high electrical load, we used thin and flexible standard stranded traces to connect all electrical components. Available, for example, at Conrad Electronics.
Male Crimp Pins
for 0.1″ Housings
We used male crimp contacts to fabricate cable that fit into the female pin sockets of the DAPLink programmer. Available, for example, at Pololu.
0.1″ Crimp Connector Housing: 1×1-Pin In order to protect the male crimp contacts, we used standard crimp housings. Available, for example, at Pololu.
Heat Shrink Tubing
d=1.20mm; ratio: 2:1
We used heat shrink tubings to insulate the jumper cable that we fabricated with the male pin headers and thin cables.
Male Pin Headers To fabricate small jumper cables, we used tiny machine pins (swiss round pins). However, it is of course also possible to use standard ones. For example, available at Adafruit.
Optical fiber cable
d=0.03″/0.75mm
We used an optical fiber cable to make the built-in LEDs visible in the housing. Available, for example, at Amazon.
Required 3D-printed components
3D Model Description
DAPLink Programmer Housing
DAPLink_Housing-Top.stl
DAPLink_Housing-Bottom.stl


In order to program the controller you have to connect GND, SWCLK and SWDIO and power the board (e.g., by using the integrated LiPo-battery or USB power). For further connections details on how to connect the DAPLink programmer to the motor control board, please refer to the circuit diagram illustration.

Setup Arduino IDE

In order to program the microcontroller, please install the latest version of the Arduino IDE. Furthermore, you have to:

Add the RedBear BLE Nano V2 Board
To use the BLE Nano V2 in Arduino, you have to add https://redbear.github.io/arduino/package_redbear_nRF5x_index.json to the additional Board Manager URL form and install the RedBear nRF52832 Boards (32-bits ARM Cortex-M4F) package via the Board Manager.

Install the SparkFun External EEPROM library
In addition, you have to install the SparkFun External EEPROM library. You can easily do that via the Arduino integrated library manager (just type in “SparkFun EEPROM”) or install it manually by downloading it from GitHub.

Arduino Sketch

/* Rapid Iron-on User Interfaces: Hands-on Fabrication of Interactive Textile Prototypes
   - Konstantin Klamka, Raimund Dachselt & Jürgen Steimle -

   Sketch for controlling the cutting blade:
   If a user hits the push button, a short
   motor motion sequence is initiated that
   moves the blade forth and back.

   created 2019 by
   Konstantin Klamka
   Interactive Media Lab Dresden, Germany

   This example code is in the public domain.

   Project website:
   http://www.imld.de/rio/

*/

// Includes
#include <nRF5x_BLE_API.h>
#include <SparkFun_External_EEPROM.h>

 // EEPROM
ExternalEEPROM myMem;

// Device Name
#define DEVICE_NAME       "RIO_Motor_Control"
#define DEVICE_NAME_SHORT "RIO"

// GATT Service and Characteristic Addresses
#define BLE_GATT_RIO_CONTROL_SERVICE       0x713D
#define BLE_GATT_CHAR_ADDR_MOTOR_CONTROL   0x703A
#define BLE_GATT_CHAR_ADDR_MOTOR_SPEED     0x703B
#define BLE_GATT_CHAR_ADDR_CUT_TIME_OUT    0x703C
#define BLE_GATT_CHAR_ADDR_CUT_TIME_IN     0x703D
#define BLE_GATT_CHAR_ADDR_BLADE_TRIGGER   0x703E
#define BLE_GATT_CHAR_ADDR_MOTOR_DIRECTION 0x703F
#define TXRX_BUF_LEN                       20

// Pin Mapping
const int buttonPin1 = 0;
const int buttonPin2 = 1;
const int motorPwmPin = 4;
const int motorDirPin = 5;
const int ledPin = 13;

// Global State Varaibles
int16_t cuttingTimeOut = 2200;
int16_t cuttingTimeIn = 2200;
int16_t motorSpeed = 255;
int16_t motorDirectionOut = 255;
int16_t motorDirectionIn = 0;
int16_t motorDirection = 0;

int currentButtonState = 0;  // current state of the button
int lastButtonState = 1;     // previous state of the button
Ticker buttonCheckerTicker;

// BLE
BLE ble;
GattCharacteristic characteristicMotorControl(BLE_GATT_CHAR_ADDR_MOTOR_CONTROL, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE |  GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic characteristicMotorSpeed(BLE_GATT_CHAR_ADDR_MOTOR_SPEED, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic characteristicCuttingTimeOut(BLE_GATT_CHAR_ADDR_CUT_TIME_OUT, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic characteristicCuttingTimeIn(BLE_GATT_CHAR_ADDR_CUT_TIME_IN, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic characteristicBladeTrigger(BLE_GATT_CHAR_ADDR_BLADE_TRIGGER, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic characteristicMotorDirection(BLE_GATT_CHAR_ADDR_MOTOR_DIRECTION, 0, 1, TXRX_BUF_LEN, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_READ| GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE);
GattCharacteristic *uartChars[] = {&characteristicMotorControl, &characteristicMotorSpeed, &characteristicCuttingTimeOut, &characteristicCuttingTimeIn, &characteristicBladeTrigger, &characteristicMotorDirection};
GattService        uartService(BLE_GATT_RIO_CONTROL_SERVICE, uartChars, sizeof(uartChars) / sizeof(GattCharacteristic *));

// Setup
void setup() {

  // Pin configuration
  pinMode(buttonPin1, INPUT_PULLUP);
  pinMode(buttonPin2, OUTPUT);
  pinMode(ledPin, OUTPUT);
  analogWrite(motorPwmPin, 0);
  digitalWrite(buttonPin2, LOW);

  // BLE
  ble.init();
  ble.onDataWritten(gattServerWriteCallBack);
  ble.onDisconnection(disconnectionCallBack);
  setAdvertisement();
  ble.setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
  ble.addService(uartService);
  ble.setDeviceName((const uint8_t *)DEVICE_NAME);
  ble.setTxPower(4);
  ble.setAdvertisingInterval(160);
  ble.setAdvertisingTimeout(0);
  ble.startAdvertising();
 
  if (motorDirection == 0) {
      motorDirectionOut = 255;
      motorDirectionIn = 0;
    }
    else{
      motorDirectionOut = 0;
      motorDirectionIn = 255;
    }

  // Attach ticker for checking the trigger button state...
  buttonCheckerTicker.attach(checkTriggerButtonState, 0.1);
  
  Wire.begin();
  myMem.begin();
  if (myMem.begin()){loadCalibrationDataFromEEPROM();}
  delay(100);
  updateAllFromCurrentStateBLECharacteristic();
}

// Loop
void loop() {
  ble.waitForEvent();
}

void checkTriggerButtonState(void) {
  currentButtonState = digitalRead(buttonPin1);
  if (currentButtonState != lastButtonState) {
    if (currentButtonState == HIGH) {executeCut();}
    delay(50);
  }
  lastButtonState = currentButtonState;
}

void executeCut() {
  digitalWrite(ledPin, HIGH);
  analogWrite(motorDirPin, motorDirectionOut);
  analogWrite(motorPwmPin, motorSpeed);
  delay(cuttingTimeOut);
  analogWrite(motorDirPin, motorDirectionIn);
  delay(cuttingTimeIn);
  analogWrite(motorPwmPin, 0);
  digitalWrite(ledPin, LOW);
}

void gattServerWriteCallBack(const GattWriteCallbackParams *Handler) {

  // Live Motor Control
  // ---------------
  if (Handler->handle == characteristicMotorControl.getValueAttribute().getHandle()) {
    int characteristicIntValue = getCharacteristicValue(Handler);

    digitalWrite(ledPin, HIGH);
    if (characteristicIntValue > 0) {
      analogWrite(motorDirPin, motorDirectionOut);
      analogWrite(motorPwmPin, motorSpeed);
      delay(characteristicIntValue);
    }
    else
    {
      analogWrite(motorDirPin, motorDirectionIn);
      analogWrite(motorPwmPin, motorSpeed);
      delay(abs(characteristicIntValue));
    }
    analogWrite(motorPwmPin, 0);
    digitalWrite(ledPin, LOW);
  }
  
  // Motor Speed
  // ---------------
  else if (Handler->handle == characteristicMotorSpeed.getValueAttribute().getHandle()) {
    int characteristicIntValue = getCharacteristicValue(Handler);
    if (characteristicIntValue >= 255) {motorSpeed = 255;}
    else if (characteristicIntValue <= 0) {motorSpeed = 0;}
    else {motorSpeed = characteristicIntValue;}
    static uint8_t value_buffer[20];
    sprintf((char*)value_buffer, "%u", motorSpeed);
    ble.updateCharacteristicValue(characteristicMotorSpeed.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));

  }
  
  
  // Cutting Time Out
  // ---------------
  else if (Handler->handle == characteristicCuttingTimeOut.getValueAttribute().getHandle()) {
    int characteristicIntValue = getCharacteristicValue(Handler);
    if (characteristicIntValue <= 0) {cuttingTimeOut = 0;}
    else {cuttingTimeOut = characteristicIntValue;}
    static uint8_t value_buffer[20];
    sprintf((char*)value_buffer, "%u", cuttingTimeOut);
    ble.updateCharacteristicValue(characteristicCuttingTimeOut.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
  }

  // Cutting Time In
  // ---------------
  else if (Handler->handle == characteristicCuttingTimeIn.getValueAttribute().getHandle()) {
    int characteristicIntValue = getCharacteristicValue(Handler);
    if (characteristicIntValue <= 0) {cuttingTimeIn = 0;}
    else {cuttingTimeIn = characteristicIntValue;}
    static uint8_t value_buffer[20];
    sprintf((char*)value_buffer, "%u", cuttingTimeIn);
    ble.updateCharacteristicValue(characteristicCuttingTimeIn.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
  }

  // Cutting Trigger
  // ---------------
  else if (Handler->handle == characteristicBladeTrigger.getValueAttribute().getHandle()) {
    if (getCharacteristicValue(Handler) == 1) {executeCut();}
  }

  // Motor Direction
  // ---------------
  else if (Handler->handle == characteristicMotorDirection.getValueAttribute().getHandle()) {
    if (getCharacteristicValue(Handler) == 0) {
      motorDirection = 0;
      motorDirectionOut = 255;
      motorDirectionIn = 0;
      static uint8_t value_buffer[20];
      sprintf((char*)value_buffer, "%u", motorDirection);
      ble.updateCharacteristicValue(characteristicMotorDirection.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
    }
    else{
      motorDirection = 1;
      motorDirectionOut = 0;
      motorDirectionIn = 255;
      static uint8_t value_buffer[20];
      sprintf((char*)value_buffer, "%u", motorDirection);
      ble.updateCharacteristicValue(characteristicMotorDirection.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));

    }
  }

  saveAllCalibrationData();
}

void setAdvertisement(void) {
  ble.accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED | GapAdvertisingData::LE_GENERAL_DISCOVERABLE);
  ble.accumulateAdvertisingPayload(GapAdvertisingData::SHORTENED_LOCAL_NAME, (const uint8_t *)DEVICE_NAME_SHORT, sizeof(DEVICE_NAME_SHORT) - 1);
  ble.accumulateScanResponse(GapAdvertisingData::COMPLETE_LOCAL_NAME, (const uint8_t *)DEVICE_NAME, sizeof(DEVICE_NAME) - 1);
}

void disconnectionCallBack(const Gap::DisconnectionCallbackParams_t *params) {
  ble.startAdvertising();
}

int getCharacteristicValue(const GattWriteCallbackParams *Handler) {
  String characteristicStringValue;
  for (int index = 0; index < Handler->len; index++) {
    characteristicStringValue.concat((char)Handler->data[index]);
  }
  return characteristicStringValue.toInt();
}

void saveAllCalibrationData(){

// cuttingTimeOut
myMem.write(0, highByte(cuttingTimeOut));
myMem.write(1, lowByte(cuttingTimeOut));  

// cuttingTimeIn
myMem.write(2, highByte(cuttingTimeIn));
myMem.write(3, lowByte(cuttingTimeIn)); 

// motorSpeed
myMem.write(4, highByte(motorSpeed));
myMem.write(5, lowByte(motorSpeed)); 

// motorDirection
myMem.write(6, highByte(motorDirection));
myMem.write(7, lowByte(motorDirection)); 
  
}

void loadCalibrationDataFromEEPROM(){
  cuttingTimeOut = ((byte)myMem.read(0) << 8) + myMem.read(1);
  cuttingTimeIn = ((byte)myMem.read(2) << 8) + myMem.read(3);
  motorSpeed = ((byte)myMem.read(4) << 8) + myMem.read(5);
  motorDirection = ((byte)myMem.read(6) << 8) + myMem.read(7);
}
 void updateAllFromCurrentStateBLECharacteristic(){
    static uint8_t value_buffer[20];
    sprintf((char*)value_buffer, "%u", motorSpeed);
    ble.updateCharacteristicValue(characteristicMotorSpeed.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
    sprintf((char*)value_buffer, "%u", cuttingTimeOut);
    ble.updateCharacteristicValue(characteristicCuttingTimeOut.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
    sprintf((char*)value_buffer, "%u", cuttingTimeIn);
    ble.updateCharacteristicValue(characteristicCuttingTimeIn.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
    sprintf((char*)value_buffer, "%u", motorDirection);
    ble.updateCharacteristicValue(characteristicMotorDirection.getValueAttribute().getHandle(), (const uint8_t*)value_buffer, strlen((const char*)value_buffer));
}
  

Download the sketch here: RIO_Motor_Control.ino

3.5 Powering & Charging

The circuit and the motor could be either powered by the built-in battery or by an external USB cable. In the following, we show how we realized a LiPo Charger Module for the rapid iron motor control as well as present the USB cable as an alternative power option.

LiPo Charger Module

Partlist for the Rapid Iron-On Tool
Image Part Description
3D-Printer Filament We used black Tiertime UP Fila ABS to 3D-print a small housing for the LiPo charger module. Of course you can also use any other filament.
Optical fiber cable
d=0.03″/0.75mm
We used an optical fiber cable to make the built-in LEDs visible in the housing. Available, for example, at Amazon.
Adjustable LiPo Charger
Max. charging current 30mA
We used an adjustable LiPo charger from SparkFun which could be limited to a maximal charging current of 30mA by soldering a 34kOhm resistor on the board and activating the PTH mode. Available, for example, at SparkFun.
34k Resistor
Metal film resistor
Axial lead
0.6W
We used this resistor to limit the maximal charging current to 30mA. Available, for example, at Reichelt Elektronik.
LiPo battery
25,5mm x 12,5mm x 6,2mm; 100mAh; 3,7V; JST-PH-Connector (2mm).
In order to provide power to the microcontroller as well as the actuated motor, we integrated a small LiPo battery. If you need longer battery time, you can also choose a larger one or switch to USB power. Available, for example, at EXP-Tech.
Required 3D-printed components
3D Model Description
LiPo Charger Housing
LiPo_Charging_Housing-Top.stl
LiPo_Charging_Housing-Bottom.stl

Since our 100mAh LiPo battery has a maximum charging current of 30mA, we have to limit the LiPo chargers output current. While the charge rate controller sets the maximum charge current with a resistor, we calculate the resistor based on the following formula:


R_PTH (kΩ) = 1000V / I_set (mA)


Therefore, we solder a 34k resistor on the board to limit the charging current to approx. 30mA and select the PTH mode by moving the DIP switch labeled “PTH” to the ON position.

USB Power
If you want to use 5V USB power instead the LiPo battery that we placed in the motor control unit, you can do this quite easily. Therefore, we just had to solder a USB to 2-Pin JST connector. This is possible due to the fact that the motor controller board uses a voltage regulator.

Partlist for the usb power cable
Image Part Description
3D-Printer Filament We used black Tiertime UP Fila ABS to 3D-print a small housing that covers the connections between the USB cable and the JST connector. Of course you can also use any other filament.
USB 2.0 cable
Type A; open contacts
If you want to realize the actuated blade without a battery, it is possible to use the 5V of a standard USB cable. Therefore, we used a type A cable with open contacts and soldered a 2-Pin JST connector to it to make it compatible to our motor control circuit as an battery replacement. Available, for example, at Reichelt Elektronik.
JST 2-pin cable
2mm
In order to avoid additional connectors and seamlessly integrate a power option from USB for the motor driver board, we used a JST 2-pin connector as an alternative for the LiPo battery. Available, for example, at Adafruit.
Required 3D-printed components
3D Model Description
USB to 2-Pin JST Housing
USB_to_2-Pin_JST_Housing-Bottom.stl
USB_to_2-Pin_JST_Housing-Top.stl


In order to power the motor control unit with USB power, you can solder a USB to JST adapter. We further 3D-print a small case to house the soldered contacts in a save way.

3.6 Linear Actuator

Partlist for the linear actuator
Image Part Description
Micro Metal DC Motor with Gearbox
N20 motor; M4 x 55mm wave; 6V; 1000RPM; SKU: GS06340-06
We used this one from Amazon
Highflex Cable
0.05mm²; PVC 0.8mm;
10×0.08mm
Since we have no components that require high electrical load, we used thin and flexible standard stranded traces to connect all electrical components. Available, for example, at Conrad Electronics.
Heat Shrink Tubing
d=1.20mm; ratio: 2:1
We used heat shrink tubings to insulate the jumper cable that we fabricated with the male pin headers and thin cables.
Male Pin Headers To attach small jumper pins to the motor, we used tiny machine pins (swiss round pins). However, it is of course also possible to use standard ones. For example, available at Adafruit.
Reduce housing size and screw length
In order to place the linear actuator in the rapid iron-on tool, it is necessary to slightly modify the linear actuator by cutting off two parts with a hacksaw.Solder cables and connectors
Next, we solder two cables to the motor and male pins connectors. We used coloured heat shrink tubings to isolate as well as visually label the positive (red) and negative (black) contact of the motor.

Physical installation test
Finally, we check whether the linear actuator fits into the carriage model.


To prepare the motor for the installation in the carriage model you have to reduce the housing size and screw length.

3.7 Cutting Blade Carrier

Partlist for the cutting blade carrier
Image Part Description
Cutting Blades
Required 3D-printed components
3D Model Description
Cutting Blade Carrier
Cutting_Blade_Carrier_1.75.stl

3.8 Create a Bluetooth Connection

In order to physically install and calibrate the actuated cutting blade, we need to establish a Bluetooth connection in order to access the Bluetooth Low Energy GATT calibration parameters.

Desktop Bluetooth GATT explorer, like Bluetility, allow to seamlessly connect to the motor control board and read as well as write ASCII values.
In addition, several mobile applications, like BLE Scanner (Android, iOS), also allows to modify GATT characteristics on mobile platforms.

3.9 Calibration Command Overview

Please connect to the device RIO_Motor_Control and select the service 0x713D. In the following you can use the following commands:

Calibration Command Overview
GATT Characteristic Description
0x703A Motor Live Control
This characteristic gives you full motion control of the actuated cutting blade. To move the blade you just have to change the ASCII value. Please note that the motion is immediately triggered.


Parameters:
+ sets the direction to out.
sets the direction to in.
Number defines the time of actuation in milliseconds.


Examples:
+200 moves the blade 200ms out.
-500 moves the blade 500ms in.

0x703B Motor Speed
This characteristic defines the speed of the actuated cutting blade. To set the speed you just have to change the ASCII value. Please note that the change is immediately saved and applied to the next actuation.


Parameters:
Number defines speed based on pulse-width modulation (PWM).
(255 = max. speed)


Examples:
255 sets the blade to a maximal speed.
128 sets the blade to a medium speed.

0x703C Cut Time (Out)
This characteristic defines the time in milliseconds that the actuated cutting blade moves out when a user pushes the trigger button. To set the time you just have to change the ASCII value. Please note that the change is immediately saved and applied to the next actuation.


Parameters:
Number defines the time of moving out in milliseconds.


Examples:
2000 will let move the blade 2000 milliseconds move out.
100 will let move the blade 100 milliseconds move out.

0x703D Cut Time (In)
This characteristic defines the time in milliseconds that the actuated cutting blade moves in when a user pushes the trigger button. To set the time you just have to change the ASCII value. Please note that the change is immediately saved and applied to the next actuation.


Parameters:
Number defines the time of moving in in milliseconds.


Examples:
3000 will let move the blade 3000 milliseconds move in.
200 will let move the blade 200 milliseconds move in.

0x703E Blade Trigger
This characteristic remotely triggers a cutting action. To initiate a cutting process you just have to change the ASCII value. Please note that the change immediately triggers the blade.


Parameters:
Number defines whether the user wants to remotely trigger a cutting action (=move the blade forward and backward considering the previously defined calibration data). The value 1 triggers the action.


Examples:
1 the blade will move out an back based on the previously defined calibration data.
0 nothing will happen.

0x703F Motor Direction
This characteristic allows you to swap the direction of in and out or in other words the polarity.


Parameters:
Number defines the polarity. If your in and out direction is wrong, you can toggle between 0/1. Of course you can also just physically swap the pins.


Examples:
1 polarity in/out.
0 polarity out/in.

Step 4: Setup of the spring-loaded Mechanism

Required tools:
FDM 3D Printer, sandpaper (extra fine, 600 grit), fine-cut files, hacksaw (with metal saw blade), rubber mallet.

Partlist for the Rapid Iron-On Tool
Image Part Description
High-temperature ABS Filament
Print temperature: 270°C
ABS can be mechanized, polished, sanded, drilled and glued and the finish is still good. In addition, it is extremely strong, more heat-resistant and it has certain flexibility. All of which makes it the perfect material for the rapid iron-on tool. We used Tiertime UP Fila ABS.
Round Bars
Stainless steel,
d=3.00mm
We used the round bars for two purposes: First, both axis of the rapid iron-on tool are made of round bars. In addition, we also use these round bars as guide rails for the spring-loaded mechanism. Therefore we cut the round bar into different pieces of required length with a metal saw and deburred the edges with metal files. Such metal round bars are available, for example, on Ebay.
Springs
from ballpoint pens;
approx. d=4.2mm; l=25mm
We upcycled small springs from old ballpoint pens. We paid attention that the springs nicely fit above the round bars that we used. In addition, the springs should be approximately equal in their length (25mm) and spring constant to ensure a nice motion.
Required 3D-printed components
3D Model Description
Connector Carriage
ConnectorCarriage.stl

Cut the metal axes to the desired length (46mm). Assemble the metal axes with the carriage model and put over the springs.

Step 5: Integration of the Iron Adapter

Required tools:
FDM 3D Printer, sandpaper (extra fine, 600 grit), screwdriver (slotted).

Partlist for the Rapid Iron-On Tool
Image Part Description
High-temperature ABS Filament
Print temperature: 270°C
ABS can be mechanized, polished, sanded, drilled and glued and the finish is still good. In addition, it is extremely strong, more heat-resistant and it has certain flexibility. All of which makes it the perfect material for the rapid iron-on tool. We used Tiertime UP Fila ABS.
Soldering Iron
temperature adjustable, with soldering tips that are screwable (M4)
As a main heat generating component, we utilized a temperature-adjustable soldering iron with a tip that is screwable (M4). This connection allows us to mount own custom ironing plates. In detail, we build on this one from Amazon.
Threaded Inserts
M2*0.4 / M4.5*0.5; 6mm; SKU: GS08040-01
We use threaded inserts to create reusable as well as strong screw connections between different 3D-printed parts (e.g., between the carriage and the spring-loaded iron) of the rapid iron-on tool. Available, for example, on Amazon.
Required 3D-printed components
3D Model Description
Iron Connector
IronConnector.stlIronConnector_cable_guidance.stl
(extended version with a small clip to guide the motor cables)

Screw in the four threaded inserts in the iron connector part. Unscrew the lower part of the soldering iron, place the iron connector and assemble the iron again.

Step 6: Assembly of the spring-loaded Carriage and Iron

Required tools:
Screwdriver (cross-head), hacksaw (with metal saw blade), scissor and hobby knife, bench drilling machine, thread cutter M4.

Partlist for the Rapid Iron-On Tool
Image Part Description
M2 Screws
in different lengths
The M2 screws fit into the threaded inserts and allow us to strongly screw different parts together. M2 screws can be bought in different sizes at many local hardware stores.
Grub Screws
stainless steel, M4x10mm, DIN 913
We used a grub screw to connect our custom-made, exchangeable irons with the soldering iron. It might be necessary to shorten and grind the screws to perfectly fit into the setup. Available, for example, on Ebay.
Steel Sheets
S235,
thickness: 4mm
The steel sheets serve us as a base material to create the exchangeable irons for the rapid iron-on tool. Therefore, we cut out some small plates with a metal saw, drill a hole and finally use a thread cutter with cutting oil to realize a M4 screw thread. Such metal sheets are available, for example, on Ebay.
Glass Fabric Tape
PTFE, 25mm x 10m,
heat resistant up to 260°C, self-adhesive
The bonding iron is very hot and in close proximity to the spring-loaded carriage. To add an additional protection layer for accidentally physical contacts of the iron, we partly add glass fabric tape made of polytetrafluoroethylene that is able to temporarily resist heat. For our current prototype, we used this one from Amazon.

Connect the carriage model with the previously assembled iron connector by using four screws.

Saw out an iron plate (18mm x 22.8mm) of a steel sheet (thickness 4mm). Drill a hole in the iron plate. Cut a thread (size: M4) in the hole.

Screw the iron plate tight to the soldering iron screw tip.

Step 7: Assembly of the Brackets and Motor Control Unit

Required tools:
Screwdriver (cross-head).

7.1 Assembly of the Brackets

Partlist for the Rapid Iron-On Tool
Image Part Description
High-temperature ABS Filament
Print temperature: 270°C
ABS can be mechanized, polished, sanded, drilled and glued and the finish is still good. In addition, it is extremely strong, more heat-resistant and it has certain flexibility. All of which makes it the perfect material for the rapid iron-on tool. We used Tiertime UP Fila ABS.
M2 Screws
in different lengths
The M2 screws fit into the threaded inserts and allow us to strongly screw different parts together. M2 screws can be bought in different sizes at many local hardware stores.
Required 3D-printed components
3D Model Description
Holder Brackets
bracket_back.stl
bracket_front.stl
bracket_front_cable_guidance.stl
(extended version with a small cable guidance clip for the motor cables)
Mount the brackets by pushing the device down to the desired neutral position. Then fix the brackets by using four screws. Afterwards all components should have a strong connection and the spring-loaded mechanism should be easily pushed down.

If you have any problems to push or move the tool, you have to double-check and tune the tolerances of all 3D-printed part by sanding or grinding the affected parts.

7.2 Assembly of the Motor Control Unit

 
Image Part Description
High-temperature ABS Filament
Print temperature: 270°C
ABS can be mechanized, polished, sanded, drilled and glued and the finish is still good. In addition, it is extremely strong, more heat-resistant and it has certain flexibility. All of which makes it the perfect material for the rapid iron-on tool. We used Tiertime UP Fila ABS.
M2 Screws
l=8mm or l=18mm
(see options below)
The M2 screws fit into the threaded inserts and allow us to strongly screw different parts together. M2 screws can be bought in different sizes at many local hardware stores.
Threaded Inserts
M2*0.4 / M4.5*0.5; 6mm; SKU: GS08040-01
We use threaded inserts to create reusable as well as strong screw connections between the different parts of the additional cable guidance clip. Available, for example, on Amazon.
Required 3D-printed components
3D Model Description
Motor Control Mounting Cable
Motor_Control_Mounting_Cable.stl
Motor Control Mounting Iron
Motor_Control_Mounting_Iron.stl
Additional Cable Guidance for the RIO Tool
Cable_Guidance_Part_01.stl
Cable_Guidance_Part_02.stl
Different mounting options
The motor control electronics can be easily attached to the cable or to the iron itself depending on the user preferences. Therefore, you just have to use the 3D-printed brackets and matching M2 screws.
Mounting option #01:
Actuated cutting blade control attached to the cable.


Mounting option #02:
Actuated cutting blade control attached to the tool.

Step 8: Final Check

  • Check that the wheels are running smoothly and that the device can be pushed correctly.
  • Double-check that potentially hot parts have no physical contact with any component of the rapid iron-on tool.
  • Carefully validate that the iron is getting hot by using a multimeter with a temperature-measuring instrument (e.g., multimeter).

Tapes and Patches

Spools

Required tools:
FDM 3D Printer

 
Image Part Description
High-temperature ABS Filament
Print temperature: 270°C
ABS can be mechanized, polished, sanded, drilled and glued and the finish is still good. In addition, it is extremely strong, more heat-resistant and it has certain flexibility. All of which makes it the perfect material for the rapid iron-on tool. We used Tiertime UP Fila ABS.
Neodymium Magnets
Diameter: 5mm,
Thickness: 4mm
We use neodymium magnets to securely fix tapes in the quick-release fasteners spools. Available, for example, on Amazon.
Steel Tinplate
tin-plated in silver,
smooth and semi-gloss
thickness: 0.17mm
Available, for example, on Modulor.
Required 3D-printed components
3D Model Description
Quick-release Fasteners Spool (recommended version)
This spool version allows to quickly slide in a tape, magnetically lock it and supports an easy tightening of the spool.quick-release-spool-I-guide.stl (recommended)
(compatible with I-guide axis; use this version if you use the freewheel axis)

quick-release-spool-U-groove.stl
(compatible with U-groove axis; use this version if you use the bearing or basic axis)

Small Basic Spools
1x.stl
2x.stl
3x.stl
4x.stl

The quick-release fasteners spools consist of a 3D-printed part with a flexible tape fixture (left) as well as a magnetic lock mechanism (right).

Quick-release Fasteners Spool

  • 3D-print spool.
  • Cut and bend metal sheet inlay.
  • Place metal piece inside the spool.
  • Attach magnet to the spool.

The thin steel tinplate can be easily cut with a scissor.

To realize the magnetic lock mechanism, we placed a small piece of metal inside the spool. Therefore, we first cut a tape out of the metal sheet, form it with pliers and finally place it in the spool.

The completed spool consists of two parts: the 3D-printed spool with the metal sheet inside and a magnet (left). If you want to fix a tape you can use the magnet that seamlessly snaps in (right).

Carrier Layer

In order to hold the layout of the functional material in position until it is actually transferred to the textile, we used a heat-resistant carrier layer that is made of baking paper and sticky glue.

Required tools:
Something to make holes (e.g., office puncher, punch pliers, or hole puncher)

 
Image Part Description
Baking Paper
on a roll
We utilized standard baking paper on a roll that is available in most supermarkets. Please do not use special coated baking papers (e.g., with knobbed surfaces) since they will not work properly with the sticky glue. If you did not find suitable baking paper in your local supermarket, you can also order it online (e.g., Amazon). Pre cut baking paper sheets can be used for iron-on patches, but are not suitable for iron-on tapes since they are limited in their length.
Sticky Glue
Zig 2-Way Glue,
Jumbo Tip
In order to create a sticky surface, we used a Zig 2-Way Glue Pen that is blue when wet and turns clear when dry. We let the glue dry to create a tacky or sticky adhesive that is able to hold the conductive iron-on materials, but also allows to easily peel-off/dispense the material while ironing. Available, for example, on Modulor.
Rigid-PVC
flexible yet sturdy,
thickness: 0.3mm
We used a small piece of a thin and flexible PVC film to strengthen connection mechanism of the tapes’ beginning and end. Available, for example, on Modulor.

Baking Paper Tape


First, you have to cut a tape out of the baking paper in the desired length and width. Therefore, we use a cutting base, a ruler and a hobby knife. If you want to use the full width of the rapid iron-on device you have to choose a width of 2 centimeters.

Quick Release Connectors

In order to prepare the iron-on tape for the quick-release fasteners spool, we fabricated strengthened ends made of PVC foil.


To strengthen the connection of the tape, we preapre PVC foil with double-sided adhesive tape, cut the PVC foil and create a hole by using a office puncher.




Finally, you have to glue and cut the stencil and cut again a hole. The result is a carrier tape that is ready to use with the quick-release fasteners spool.

Sticky Coating

  • Use the zig 2-way glue to coat the previously created tape.
  • For most iron-on components small adhesive strips at regular intervals work.
  • Wait until the blue glue turns clear and became sticky.

For most Iron-On Tapes small adhesive strips at regular intervals work fine. If you need more adhesive power you can also coat the tape with more glue, however, you have to find a good balance between a suitable adhesion on the carrier layer as well as ensure a smooth peel off during the ironing process.

In contrast, Iron-On Patches could be always completely coated with sticky glue since the peel off process is executed manually.

Functional Layer

 
Image Part Description
Conductive Fabric
Shieldex Zell RS;
Prod. No.: 163272
A variety of conductive fabrics are available. In order to realize the trace spools we used ultra-thin, high-conductive metalized fabrics from Shieldex (Zell). You can find further technical datasheets as well as ordering options on Statex.de.
Fusible Web
Vliesofix/Bondaweb
Prod. No.: 4008983220107
We used standard Vliesofix/Bondaweb as adhesive layer. Therefore, we ironed the fusible web to the conductive fabric before we cut the functional layer and did not remove the protection layer from it at this stage. This helps us to fix/glue the fusible web and conductive fabric stack to a sacrificial plate before cutting. Vliesofix/Bondaweb is available at many local textile DIY crafting shops or online (e.g., Amazon).

Traces


Lasercut
We used an Epilog Fusion 40 M2 lasercutter to fabricate many conductive fabric parts. Please note that we bonded the fusible web layer before we lasercut the fabric.

Peel-off
Next, we removed all unnecessary fabric parts and transferred the traces by using baking paper that we coated with sticky glue beforehand.

Roll onto spools
Finally, the transferred traces need to be cut and rolled onto a spool.

Press Coverage

Rapid iron-on user interfaces is also discussed in the DIY communities and blogs: