In this article by Jonathan Witts, author of the book Wearable Projects with Raspberry Pi Zero, we will use sewable LEDs and conductive thread to transform an item of clothing into a sparkling LED piece of wearable tech, controlled with our Pi Zero hidden in the clothing. We will incorporate a Pi Zero and battery into a hidden pocket in the garment and connect our sewable LEDs to the Pi's GPIO pins so that we can write Python code to control the order and timings of the LEDs.

(For more resources related to this topic, see here.)

To deactivate the software running automatically, connect to your Pi Zero over SSH and issue the following command:

sudo systemctl disable scrollBadge.service

Once that command completes, you can shutdown your Pi Zero by pressing your off-switch for three seconds. Now let's look at what we are going to cover in this article.

What We Will Cover

In this article we will cover the following topics:

What we will need to complete the project in this article
How we will modify our item of clothing
Writing a Python program to control the electronics in our modified garment
Making our program run automatically

Let's jump straight in and look at what parts we will need to complete the project in this article.

Bill of parts

We will make use of the following things in the project in this article:

A Pi Zero W
An official Pi Zero Case
A portable battery pack
Item of clothing to modify e.g. a top or t-shirt
10 sewable LEDs
Conductive Thread
Some fabric the same color as the clothing
Thread the same color as the clothing
A sewing needle
Pins
6 metal poppers
Some black and yellow colored cable
Solder and soldering iron

Modifying our item of clothing

So let's take a look at what we need to do to modify our item of clothing ready to accommodate our Pi Zero, battery pack and sewable LEDs. We will start by looking at creating our hidden pocket for the Pi Zero and the batteries, followed by how we will sew our LEDs into the top and design our sewable circuit. We will then solve the problem of connecting our conductive thread back to the GPIO holes on our Pi Zero.

Our hidden pocket

You will need a piece of fabric that is large enough to house your Pi Zero case and battery pack alongside each other, with enough spare to hem the pocket all the way round. If you have access to a sewing machine then this section of the project will be much quicker, otherwise you will need to do the stitching by hand.

The piece of fabric I am using is 18 x 22 cm allowing for a 1 cm hem all around. Fold and pin the 1 cm hem and then either stitch by hand or run it through a sewing machine to secure your hem. When you have finished, remove the pins.

You need to then turn your garment inside out and decide where you are going to position your hidden pocket. As I am using a t-shirt for my garment I am going to position my pocket just inside at the bottom side of the garment, wrapping around the front and back so that it sits across the wearer's hip. Pin your pocket in place and then stitch it along the bottom and left and right sides, leaving the top open. Make sure that you stitch this nice and firmly as it has to hold the weight of your battery pack. The picture below shows you my pocket after being stitched in place. When you have finished this you can remove the pins and turn your garment the correct way round again.

Adding our sewable LEDs

We are now going to plan our circuit for our sewable LEDs and add them to the garment. I am going to run a line of 10 LEDs around the bottom of my top. These will be wired up in pairs so that we can control a pair of LEDs at any one time with our Pi Zero. You can position your LEDs however you want, but it is important that the circuits of conductive thread do not cross one another.

Turn your garment inside out again and mark with a washable pen where you want your LEDs to be sewn. As the fabric for my garment is quite light I am going to just stitch them inside and let the LED shine through the material. However if your material is heavier then you will have to put a small cut where each LED will be and then button-hole the cut so the LED can push through. Start with the LED furthest from your hidden pocket. Once you have your LED in position take a length of your conductive thread and over-sew the negative hole of your LED to your garment, trying to keep your stitches as small and as neat as possible, to minimize how much they can be seen from the front of the garment.

You now need to stitch small running stitches from the first LED to the second, ensure that you use the same piece of conductive thread and do not cut it! When you get to the position of your LED, again over-sew the negative hole of your LED ensuring that it is face down so that the LED shows through the fabric. As I am stitching my LEDs quite close to the hem of my t-shirt, I have made use of the hem to run the conductive thread in when connecting the negative holes of the LEDs, as shown in the following image:

Continue on connecting each negative point of your LEDs to each other with a single length of conductive thread. Your final LED will be the one closest to your hidden pocket, continue with a running stitch until you are on your hidden pocket. Now take the male half of one of your metal poppers and over-sew this in place through one of the holes. You can now cut the length of conductive thread as we have completed our common ground circuit for all the LEDs. Now stitch the three remaining holes with standard thread, as shown in this picture.

When cutting the conductive thread be sure to leave a very short end. If two pieces of thread were to touch when we were powering the LEDs we could cause a short circuit.

We now need to sew our positive connections to our garment. Start with a new length of conductive thread and attach the LED second closest to your hidden pocket. Again over-sew it it to the fabric trying to ensure that your stitches are as small as possible so they are not very visible from the front of the garment. Now you have secured the first LED, sew a small running stitch to the positive connection on the LED closest to the hidden pocket. After securing this LED stitch a running stitch so that it stops alongside the popper you previously secured to your pocket, and this time attach a female half of a metal popper in the same way as before, as shown in this picture:

Secure your remaining 8 LEDs in the same fashion, working in pairs, away from the pocket. so that you are left with 1 male metal popper and 5 female metal poppers in a line on your hidden pocket. Ensure that the 6 different conductive threads do not cross at any point, the six poppers do not touch and that you have the positive and negative connections the right way round! The picture below shows you the completed circuit stitched into the t-shirt, terminating at the poppers on the pocket.

Connecting our Pi Zero

Now we have our electrical circuit we need to find a way to attach our Pi Zero to each pair of LEDs and the common ground we have sewn into our garment. We are going to make use of the poppers we stitched onto our hidden pocket for this. You have probably noticed that the only piece of conductive thread which we attached the male popper to was the common ground thread for our LEDs. This is so that when we construct our method of attaching the Pi Zero GPIO pins to the conductive thread it will be impossible to connect the positive and negative threads the wrong way round! Another reason for using the poppers to attach our Pi Zero to the conductive thread is because the LEDs and thread I am using are both rated as OK for hand washing; your Pi Zero is not!

Take your remaining female popper and solder a length of black cable to it, about two and a half times the height of your hidden pocket should do the job. You can feed the cable through one of the holes in the popper as shown in the picture to ensure you get a good connection. For the five remaining male poppers solder the same length of yellow cable to each popper. The picture below shows two of my soldered poppers.

Now connect all of your poppers to the other parts on your garment and carefully bend all the cables so that they all run in the same direction, up towards the top of your hidden pocket. Trim all the cable to the same length and then mark the top and bottom of each yellow cable with a permanent marker so that you know which cable is attached to which pair of LEDs. I am marking the bottom yellow cable as number 1 and the top as number 5. We can now cut a length of heat shrink and and cover the loose lengths of cable, leaving about 4 cm free to strip, tin and solder onto your Pi. You can now heat the heat shrink with a hair dryer to shrink it around your cables.

sewable-leds-clothing-img-6

We are now going to stitch together a small piece of fabric to attach the poppers to. We want to end up with a piece of fabric which is large enough to sew all six poppers to and to stitch the uncovered cables down to. This will be used to detach the Pi Zero from our garment when we need to wash it, or just remove our Pi Zero for another project. To strengthen up the fabric I am doubling it over and hemming a long and short side of the fabric to make a pocket. This can then be turned inside out and the remaining short side stitched over.

You now need to position these poppers onto your piece of fabric so that they are aligned with the poppers you have sewn into your garment. Once you are happy with their placement, stitch them to the piece of fabric using standard thread, ensuring that they are really firmly attached. If you like you can also put a few stitches over each cable to ensure they stay in place too.

Using a fine permanent marker number both ends of the 5 yellow cables 1 through 5 so that you can identify each cable. Now push all 6 cables through about 12 cm of shrink wrap and apply some heat from a hair dryer until it shrinks around your cables.You can strip and tin the ends of the six cables ready to solder them to your Pi Zero. Insert the black cable in the ground hole below GPIO 11 on your Pi Zero and then insert the 5 yellow cables, sequentially 1 through 5, into the GPIO holes 11, 09, 10, 7 and 8 as shown in this diagram, again from the rear of the Pi Zero. When you are happy all the cables are in the correct place, solder them to your Pi Zero and clip off any extra length from the front of the Pi zero with wire snips.

You should now be able to connect your Pi Zero to your LEDs by pressing all 6 poppers together. To ensure that the wearer's body does not cause a short circuit with the conductive thread on the inside of the garment, you may want to take another piece of fabric and stitch it over all of the conductive thread lines. I would recommend that you do this after you have tested all your LEDs with the program in the next section. We have now carried out all the modifications needed to our garment, so let's move onto writing our Python program to control our LEDs.

Writing Our Python Program

To start with we will write a simple, short piece of Python just to check that all ten of our LEDs are working and we know which GPIO pin controls which pair of LEDs. Power on your Pi Zero and connect to it via SSH.

Testing Our LEDs

To check that our LEDs are all correctly wired up and that we can control them using Python, we will write this short program to test them.

First move into our project directory by typing:
```
cd WearableTech
```
Now make a new directory for this article by typing:
```
mkdir Chapter3
```
Now move into our new directory:
```
cd Chapter3
```
Next we create our test program, by typing:
```
nano testLED.py
```

Then we enter the following code into Nano:

#!/usr/bin/python3


      from gpiozero import LED
      from time import sleep


      pair1 = LED(11)
      pair2 = LED(9)
      pair3 = LED(10)
      pair4 = LED(7)
      pair5 = LED(8)


      for i in range(4):
          pair1.on()
          sleep(2)
          pair1.off()
          pair2.on()
          sleep(2)
          pair2.off()
          pair3.on()
          sleep(2)
          pair3.off()
          pair4.on()
          sleep(2)
          pair4.off()
          pair5.on()
          sleep(2)
          pair5.off()

Press Ctrl + o followed by Enter to save the file, and then Ctrl + x to exit Nano. We can then run our file by typing:

python3 ./testLED.py

All being well we should see each pair of LEDs light up for two seconds in turn and then the next pair, and the whole loop should repeat 4 times.

Our final LED program

We will now write our Python program which will control our LEDs in our t-shirt. This will be the program which we configure to run automatically when we power up our Pi Zero. So let's begin...

Create a new file by typing:
```
nano tShirtLED.py
```

Now type the following Python program into Nano:

#!/usr/bin/python3
from gpiozero import LEDBoard
from time import sleep
from random import randint
leds = LEDBoard(11, 9, 10, 7, 8)
while True:
for i in range(5):
wait = randint(5,10)/10
leds.on()
sleep(wait)
leds.off()
sleep(wait)
for i in range(5):
wait = randint(5,10)/10
leds.value = (1, 0, 1, 0, 1)
sleep(wait)
leds.value = (0, 1, 0, 1, 0)
sleep(wait)
for i in range(5):
wait = randint(1,5)/10
leds.value = (1, 0, 0, 0, 0)
sleep(wait)
leds.value = (1, 1, 0, 0, 0)
sleep(wait)
leds.value = (1, 1, 1, 0, 0)
sleep(wait)
leds.value = (1, 1, 1, 1, 0)
sleep(wait)
leds.value = (1, 1, 1, 1, 1)
sleep(wait)
leds.value = (1, 1, 1, 1, 0)
sleep(wait)
leds.value = (1, 1, 1, 0, 0)
sleep(wait)
leds.value = (1, 1, 0, 0, 0)
sleep(wait)
leds.value = (1, 0, 0, 0, 0)
sleep(wait)

Now save your file by pressing Ctrl + o followed by Enter, then exit Nano by pressing Ctrl + x. Test that your program is working correctly by typing:
```
python3 ./tShirtLED.py
```

If there are any errors displayed, go back and check your program in Nano. Once your program has gone through the three different display patterns, press Ctrl + c to stop the program from running.

We have introduced a number of new things in this program, firstly we imported a new GPIOZero library item called LEDBoard. LEDBoard lets us define a list of GPIO pins which have LEDs attached to them and perform actions on our list of LEDs rather than having to operate them all one at a time. It also lets us pass a value to the LEDBoard object which indicates whether to turn the individual members of the board on or off. We also imported randint from the random library. Randint allows us to get a random integer in our program and we can also pass it a start and stop value from which the random integer should be taken. We then define three different loop patterns and set each of them inside a for loop which repeats 5 times.

Making our program start automatically

We now need to make our tShirtLED.py program run automatically when we switch our Pi Zero on:

First we must make the Python program we just wrote executable, type:
```
chmod +x ./tShirtLED.py
```
Now we will create our service definition file, type:
```
sudo nano /lib/systemd/system/tShirtLED.service
```

Now type the definition into it:

[Unit]
      Description=tShirt LED Service
      After=multi-user.target


      [Service]
      Type=idle
      ExecStart=/home/pi/WearableTech/Chapter3/tShirtLED.py



      [Install]
      WantedBy=multi-user.target

Save and exit Nano by typing Ctrl + o followed by Enter and then Ctrl + x. Now change the file permissions, reload the systemd daemon and activate our service by typing:
```
sudo chmod 644 /lib/systemd/system/tShirtLED.service

      sudo systemctl daemon-reload

      sudo systemctl enable tShirtLED.service
```

Now we need to test whether this is working, so reboot your Pi by typing sudo reboot and then when your Pi Zero restarts you should see that your LED pattern starts to display automatically. Once you are happy that it is all working correctly press and hold your power-off button for three seconds to shut your Pi Zero down.

You can now turn your garment the right way round and install the Pi Zero and battery pack into your hidden pocket. As soon as you plug your battery pack into your Pi Zero your LEDs will start to display their patterns and you can safely turn it all off using your power-off button.

sewable-leds-clothing-img-8

Summary

In this article we looked at making use of stitchable electronics and how we could combine them with our Pi Zero. We made our first stitchable circuit and found a way that we could connect our Pi Zero to this circuit and control the electronic devices using the GPIO Zero Python library.