Nobody likes hat hair, but that's no reason to let your ears freeze! Earwarmers are the perfect compromise -- cute and warm, but plenty of room for your hair to breathe free.

And by doubling the fabric to create a tube, you've got a handy place to hide a small battery holder -- enough to power a string of festive LEDs or stitch on some programmable NeoPixels!

This super-simple project lets you dress up your winter wear three different ways:

1. Use basic embroidery stitches to add a string of LEDs on a lovely silver wire, no coding required!
2. Go a little fancier with color-changing NeoPixels controlled by a Gemma M0 programmed in easy-to-learn Microsoft MakeCode.
3. For a challenge, weave a little CircuitPython magic into the Gemma to tap into a secret temperature sensor that shows you the chill factor in colored NeoPixels.

Suggested Tools List

Here are some recommended tools, but feel free to use what you have on hand. Standard crewel (embroidery) needles also work well with conductive thread.

Suggested Materials List

The construction of the earwarmer headband is the same for all three versions. Here's what you will need, in addition to the parts and tools listed above:

• felt or fleece (in one or more colors) -- warm, soft, and easy to sew because they don't fray. The nice thick felt used for the examples in this guide was made by shrinking wool sweaters  (Instructions for felting sweaters can be found multiple places online or in my book Fabric and Fiber Inventions)
• regular cotton or polyester thread -- use where you want stitches to be secure but not overly visible
• embroidery floss -- great for decorative stitching that draws attention, and for covering up electronics
• straight pins -- to hold the fabric together while you work
• seam ripper -- for fixing mistakes

Optional, depending on the version you'll be making:

• tape (for holding the wire LEDs in place as you sew)
• adhesive dots (tiny ones to hold the NeoPixels in place as you sew)
• liquid seam sealant like Fray Check, or clear nail polish (for securing the conductive thread)
• press-on fabric adhesive sheets, such as Peel n Stick Fabric Fuse (for attaching felt appliques over NeoPixels and conductive thread stitches) 

Measure and Cut Your Fabric

The first step is to cut your piece of fabric to fit your head. Use a cloth tape measure, piece of yarn, or your fabric to measure the width and length you like. This project is very forgiving, so don't worry if something doesn't come out exactly as you meant it to. It will probably still work.

Cut out a strip of fabric using those measurements. If you need help, draw a paper pattern first, or draw on the fabric with tailor's chalk (or blackboard chalk if that's what you have lying around).

Mark and Stitch the Back Seam

To make the headband, fold the fabric strip in half, long edges together. The "right side" of the fabric (the side you want to show) should be facing out.

The folded edge is the front of the headband, closest to your face. The two short ends will be stitched together and go at the back of your neck.

For this version of the headband, you'll be sewing a wire light onto the headband. The wire light is all one piece -- all you have to do is stitch around it to hold it in place. And it's waterproof, so it's OK to wear in damp weather (as long as the battery pack is tucked away inside the headband).

Since the stitches will be showing, you might as well make them part of the design! To do that, you will use embroidery floss -- a thick, shiny thread made up of six strands that can be separated or used all together.

And since the lights are pretty bright, you can also use embroidery floss stitches to cover the LEDs and diffuse the light. That reduces the intensity and spreads the light around to cover a slightly larger area.

You don't need to know any official stitches for this project -- it's perfectly OK to just make them up as you go along.

If you need help with the basics, The Hand Sewing Class on Instructables can help you get started, and give pointers on the stitches mentioned here. The Instructables Embroider Class also has tips for sewing with embroidery floss.

Position the Wire Lights

Attach the Wire to the Fabric

Embroider Over the LEDs

Closing the Top

The final step is to close the top of the headband. Starting at the bottom of the back seam, sew through all the layers of fabric, gathering them together in the stitch.

When you reach the top edge, go all the way around.

If you make a mistake in your embroidery, you can take out the stitches with a seam ripper and start again. Just be careful not to damage the wire or electronics.

Want to add programming? With a Gemma M0 and Flora RGB Smart NeoPixels, you can create a string of lights that's codable in multiple formats. It lets you flash the lights on and off and change color, individually, to create an infinite variety of lighting effects.

All you need are the same sewing skills you just used to construct your earwarmer. If you're new to sewing circuits, there's a detailed guide to working with conductive thread here.

Prep Your Circuit

To connect additional NeoPixels to the circuit, line them up so they are all pointing away from the Gemma. Then connect the arrow on the other side of the NeoPixel board to the arrow on the next NeoPixel.

You must use separate piece of conductive thread for the signal trace between each NeoPixel board.

The thread for the power and ground can each just continue on from one LED to the next.

Check once more that no loose threads are touching anything they shouldn't.

Then test your circuit by running a program on the Gemma M0. Go to the MakeCode page or the CircuitPython page to program the board, depending on which version you want to use.

The next pages tell you how to program your lights in either MakeCode or CircuitPython!

It's simple to program your Twinkly Earwarmer with the Gemma M0 in Microsoft MakeCode! The version to use with Gemma M0 is called MakeCode Maker. It lets you program the onboard color-changing LED, and add components to the board's pins.

For this project, you need to tell the board where to find a strip of four external NeoPixels. Combine them with Gemma's onboard RGB DotStar LED and you can create an animated light show with five lights!

If you haven't used Gemma M0 with MakeCode before, There's more information about using MakeCode on the Gemma M0 guide.

To get started right away, you can just open and edit the sample code shown at the top of the page.

Click the button below to open the MakeCode Maker editor, then add to or change the light display as you wish.

To download the file to the board, connect the Gemma M0 to your computer with the USB cable. Press the reset button and it will go into bootloader mode. That means it's ready to receive code.

Click Download on the MakeCode page and save the file. It will have a .uf2 extension.

Then find the drive on your computer labeled GEMMABOOT. Drag and drop (or copy and paste) the program into Gemma! You'll know the code was downloaded when the onboard pixel changes to violet.

While the Gemma is still connected to the computer, check how the MakeCode runs on the actual NeoPixel strip so you can make any adjustments.

There are lots of ways to animate your strip of pixels! To create your own animation, you can use the strip code blocks, found in the LIGHT category. Then you can preview it in the simulator before you download it to your Gemma.

Here's a detailed explanation of how the NeoPixels work and how to make them do interesting things.

You can see and edit the handcoded animation shown above by clicking the button below. Have fun!

Want more of a challenge? If you code the board in CircuitPython, you can access the hidden temperature sensor and use it to control the colors of your pixels!

Adafruit's Anne Berela has written code that will turn the lights red if the temperature is above 65 degrees and blue if it goes below that. 

If you are new to CircuitPython, there are few steps to go through to use this code. Follow the instructions below or go here to learn more about installing and programming in CircuitPython.

Loading CircuitPython on Your Gemma M0

This project was tested using CircuitPython 4. If you're not sure if that's what you are running on your Gemma M0, plug in your board, go to CIRCUITPY drive, and check the folder marked boot_out.txt. It will tell you what version is loaded on the board. The latest stable version should be fine.

If you need to install or update CircuitPython, tap the reset button once or twice to enter bootloader mode.

Once successful, the RGB LED on the board will flash red and then stay green. A new drive will show up on your computer called GEMMABOOT.

Then click the button below, which will take you to the download page for the latest version of CircuitPython. Save that file to the GEMMABOOT drive on your computer.

You've now installed CircuitPython on your board! The drive you will be working with from here on is called CIRCUITPY.

Next, you'll need to install some libraries. CircuitPython libraries are separate files designed to work with CircuitPython code. CircuitPython programs require a lot of information to run. CircuitPython is so simple to use because most of this information is processed in the background and stored in libraries. Some libraries are built into CircuitPython. Others are downloaded and stored on your CIRCUITPY drive in a folder called lib.

Click the button below and download the bundle for use with your version of CircuitPython. Save it on your computer, not the board! You'll only need two files from this huge folder.

Look for these two files -- neopixel.mpy and adafruit_dotstar.mpy -- and drag them to the lib folder on the Gemma M0.

Install the Mu Editor

Adafruit recommends using the Mu editor on your computer to work with CircuitPython code. Instructions for downloading it to your computer can be found here or the button below.

Once you've got it installed, open it up. You're ready to copy the code to make your temperature sensor lights work!

Temperature Sensor Code

Copy and paste the code below into your editor or click the download link.

# SPDX-FileCopyrightText: 2019 Anne Barela for Adafruit Industries
#
# SPDX-License-Identifier: MIT

# Gemma M0 Onchip Temperature Sensor
# Project by Kathy Ceceri
# CircuitPython by Anne Barela
# Adafruit Industries, 2019

import time
import board
import microcontroller
import neopixel
import adafruit_dotstar

ROOM_TEMP = 65.0  # Set this to the temp to change from blue to red (F)

# Set up NeoPixel strand
pixels = neopixel.NeoPixel(board.D1,  # NeoPixels on pin D1
                           4,         # Number of Pixels
                           brightness=0.2)   # Change from 0.0 to 1.0

# For the Gemma M0 onboard DotStar LED
dotstar = adafruit_dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1)

def deg_f(deg_c):  # Convert celsius to Fahrenheit
    return(deg_c * 9 / 5) + 32.0

while True:
    temp = deg_f(microcontroller.cpu.temperature)
    if temp > ROOM_TEMP:
        pixels.fill((255, 0, 0))   # (255,0,0) is red
        dotstar.fill((255, 0, 0))  # Set to red
    else:
        pixels.fill((0, 0, 255))   # (0,0,255) is blue
        dotstar.fill((0, 0, 255))  # Set to blue

    time.sleep(1.0)  # Wait 1 second

# SPDX-FileCopyrightText: 2019 Anne Barela for Adafruit Industries
#
# SPDX-License-Identifier: MIT

# Gemma M0 Onchip Temperature Sensor
# Project by Kathy Ceceri
# CircuitPython by Anne Barela
# Adafruit Industries, 2019

import time
import board
import microcontroller
import neopixel
import adafruit_dotstar

ROOM_TEMP = 65.0  # Set this to the temp to change from blue to red (F)

# Set up NeoPixel strand
pixels = neopixel.NeoPixel(board.D1,  # NeoPixels on pin D1
                           4,         # Number of Pixels
                           brightness=0.2)   # Change from 0.0 to 1.0

# For the Gemma M0 onboard DotStar LED
dotstar = adafruit_dotstar.DotStar(board.APA102_SCK, board.APA102_MOSI, 1)

def deg_f(deg_c):  # Convert celsius to Fahrenheit
    return(deg_c * 9 / 5) + 32.0

while True:
    temp = deg_f(microcontroller.cpu.temperature)
    if temp > ROOM_TEMP:
        pixels.fill((255, 0, 0))   # (255,0,0) is red
        dotstar.fill((255, 0, 0))  # Set to red
    else:
        pixels.fill((0, 0, 255))   # (0,0,255) is blue
        dotstar.fill((0, 0, 255))  # Set to blue

    time.sleep(1.0)  # Wait 1 second

If you need to make any adjustments, such as changing the "room temperature" cut-off that triggers the colors (ROOM_TEMP), or you have a different number of pixels attached to your Gemma M0, you can type them right into the code.

Then click the Save button at the top of the Mu editor and save this file as code.py on your CIRCUITPY drive.

If everything is working, the onboard LED (and the external NeoPixels if they're connected) will turn red.

Like any tech project, it takes some fiddling to make the hardware and software cooperate. Enjoy playing with your temp-sensing headgear!