Wearable Platform

Once the mechanical components were working well, the next step is making it wearable.  The original idea was to make it as a sleeve for the lower arm, so a pattern needed to be developed.

One common method used by people who make their own costumes, cosplayers, uses a thin plastic and tape.

IMAG1556.jpg

First step is wrap and secure plastic around the area a pattern is wanted.  The plastic can be saran wrap, a grocery sack, trash bag, or anything similar.

Covering the plastic in between the taped boarders, making sure to keep the tape as smooth as possible, is the next task.

IMAG1561.jpg

Carefully remove with scissors, trim off the excess plastic around the edges, and cut the piece in half.

Using one of the halves, trace the shape out on a piece of scrap card board.  Then draw a second line half inch away, all the way around the shape for a seam allowance.

This pattern is then used to cut out the needed layers of fabric that will house all the components for the second prototype.

IMAG1575.jpg

The Power Struggle

As with all wearable technology projects I’ve worked on, power is one of the big challenges.  There are all sorts of really cool things you can make, but as soon as your system requires 12V to run, it becomes unwieldy and not really wearable unless it’s a backpack to start with.Screenshot_20180731-100826_1_1.jpg

 

here is a fairly compact 12V battery pack, I found on Amazon, but it still weighs almost a pound.  Doable for some applications, but wouldn’t work to wear on the forearm and at $34 each, makes it difficult to have a couple extra on hand

 
Screenshot_20180731-102021_1.jpg

 

In the past, I have been very pleased with Sparkfun’s 5V rechargeable power bank for both function and affordability.  It is compact and light weight, comes with a cord to power your project and recharge the battery.  Additionally, the power button on the battery can double as an on/off switch for the entire project.

 

The big problem with the initial prototype is that the solenoid valves needed 12V to open and close.  With a bit of digging and research, I was able to find some 5V solenoids as well as a mini air pump, and ordered some for the next iteration of this project.

For my initial prototype and testing, I was using an Arduino Uno and a Sparkfun RedBoard for the micro controller, however, I’m going to switch to a much smaller ProMicro board now that the code has been tested.

First Prototype

IMAG1513.jpgUsing my concept sketch, I created a digital version  of the design in Illustrator.

With the laser cutter and assistance from and lab mate, we cut out a piece of non-adhering paper to sandwich between the heat sealable nylon.

To get the pouches in the prototype to bend, I referenced the work done by the MIT Media Lab. “aeroMorph – Heat-sealing Inflatable Shape-change Materials for Interaction Design

Screenshot_20180731-080107_1.jpg

After fusing the nylon with a heat press, but leaving one side open, the small valves were installed, and then the last side sealed.

 

 

Test with a hand pump:

This wasn’t quit the dramatic shape change I was hoping for, but not too bad for a first try.

The next step was to hook it up to a system with tubes, an air pump and small solenoid valves.

Test Code

Even with all the components wired to a bread board, all the components, except for power, for this project fit into a small flat box.  Still a bit big to wear on your arm, but a few adjustments and I think it will work.

Functional Code with Buttons

 

The prototype worked pretty well.  The level tracking function worked, and partially inflated the correct pouches.

Problems:

  1. Power!  The current system needs different power sources to run the valves, pump, and microcontroller.  Additionally, a 12V battery pack will certainly interfere with the “wearability” of the device.
  2. Shape changing is too subtle.  Need to make the pouches bigger, or change the angle of the fused shape in middle of pouches, or separate the pouches and make them individual, or rewrite code so there is more air pressure flowing into each pouch, or some combination of these options.
  3. Material.  After running the test code for a while, some of the pouches started to leak and wouldn’t inflate all the way.  I’d also like to look into getting plastic fixtures for attaching the pump to the pouches to lower weight and cost.

 

 

Wearable Soft Haptic Controller

Working in the “ThingLab” over the summer on a couple different projects involving haptic control interfaces and pneumatics inspired the development of this one.

According to Google, the definition of haptic is: “relating to the sense of touch, in particular relating to the perception and manipulation of objects using the senses of touch and proprioception.”  In controlling the many systems we interact with daily, there are situations where visual faculties are occupied, obscured, or permanently impaired so discovery and control are delegated to our hands.

As a first attempt, I thought a simple controller defining levels with up and down selector pads would be useful and have broad application(volume, fan speed, etc…).  The outer forearm seemed like a good place to attach it to a human body as there will be minimal interference during activity and can be worn over clothing if needed.  A Vambrace in terms of armor.

 

Here is a first concept sketch of what I’m thinking.  Some air-tight pouches hooked up to tubing that connects to a tiny pump and some sensors embedded under the (+) and (-) to act as control buttons.

IMAG1507.jpg
first concept sketch

 

hu-LED hoop

The basic idea for this project is to program a score tracking feature into a hula hoop and use LEDs to communicate to the user how many revolutions they have completed so they don’t have to stop and check their score.

The Building Process

Supplies:

Tools:

  • Soldering Iron
  • Hot glue gun
  • Wire stripper
  • Pliers
  • Wire snips

Schematic:

Measured the length of the tube and decided to use 40 LEDs alternating in groups of three and one.

The next step was to spend most of a day soldering all the LEDs back together in a long strand and testing them periodically to make sure all the lights work. After soldering the wires onto the pads, I coated all the of the contact points with hot glue to make the string more durable and help prevent shorting out the system.

This slideshow requires JavaScript.

A common challenge with physical computing projects is figuring out how to power them. I had a 5V power bank so I took it apart and found out that it happened to fit perfectly into the tube. I liked that this power bank has a on/off button built in, which allows it to function as a power switch for the whole project.

Cutting some notches out of the end of the tube set the components more securely.

In order to get the micro-controller to fit in the tube, I decided not to solder header pins onto it, and instead soldered the three wires from the sensor and the three wires to the LED strip directly to the board.

Because the tube is translucent, the sensor wasn’t triggering the score function in bright sunlight, so I took a piece of heat shrink tubing and cut a small piece to limit the field of light hitting the sensor. This worked quite well. The company I got the tubing from included a short piece of smaller diameter tube that fits snugly inside the hoop to give a hula hoop some structural stability, so I used this piece to house my sensor.

This slideshow requires JavaScript.

Then, I folded up the short USB/micro cord I had inside behind the sensor breakout board so that when the hoop is completed, the USB plugs into the battery pack. This layout also makes it easy to open it up and reprogram the pro micro.

The final step was to create an enclosure using the moldable plastic to create a sort of cage to keep the two ends of the tube together. Additionally, I made some counter weights to help balance out the weight of the battery and the electronics so the hoop rotates more evenly.

The Programming:

Writing the code for this project, I came up against way more obstacles than I would have expected. The concept is pretty simple: if the light sensor level reads below 5, then the “score’ increases by one. I originally wanted there to be nine “levels” that would trigger different light animations so the user would know when they hit a certain number of rotations.

Unfortunately, the program got glitchy after counting to 30, and the pro micro didn’t seem to be able to handle 9 different animations from the ALA library, so I had to limit the counting to a score of 20 and automatically reset to 0 at that point, and limit the number animations to three. If the score is less than 5, then glowing blue, between 5-10 a glowing red, and between 10-20 bright flashing red and yellow.

Link to gist

What I Learned

Embedding electronics into an odd shaped enclosure is an interesting experience.  I ended up having to tie a metal screw to the end of a piece of string and then pull it through the tube using a magnet so I could then use the string to pull the string of lights into the tube.

Also, it turns out that using a light sensor is perhaps not the best choice because it only works if the is a significant amount of ambient light, and the best environments for a light up hula hoop are lower light situations.

Here is a short video of it working, but it is a little hard to see the LEDs in the daylight:

Finally, I really like working with the ALA Library, but found that it has some limitations if your using a board with limited memory.

Improvements

I would like to experiment with some different sensors, accelerometer, pressure sensor, and maybe just a button to see if any of these work better for lower light conditions where LEDs show up better.

hula

It would also be fun to get a radio chip and play with using the hula hoop as a controller interface for a separate installation.

For example, perhaps the faster a user spins the hula hoop, the faster a toy hula girl dances, using some motors to make the doll move in matched speed.

Analog I/O and Enclosure

Part 1:

Build an interactive circuit that uses at least two different variable resistors (inputs) and some kind of output (sound, light, movement).

For part one one this exercise, I played around with several different sensors and the first circuit I built used a slider, a flex sensor, and a photo resistor each mapped to control the brightness of three different colored LEDs.

https://giphy.com/embed/kv5o7UINQKiDdYzxfu

IMAG1248

After having good success with this experiment using multiple sensors to control multiple lights, I wanted to try using multiple sensors to control a single RGB LED. The photo sensor wasn’t “playing well with others” so I replaced it with a potentiometer.

IMAG1251

This gave me an idea for Part 2 of this exercise to make a color blending sort of toy, using three potentiometers, so rebuilt the circuit with three regular LEDs, red green blue, and one RGB LED. Each potentiometer controls one color. The Red pot is mapped to the single red LED as well as to the red pin on the RGB LED, so when it is turned it controls both.

________________________________________________

Part 2:

Build a custom enclosure for your project – the enclosure can be soft or hard but it must fully hide your electronics.
Parts: variable resistors, photo resistor, micro-controller, breadboard, fabrication materials

I decided to make a color mixing toy, so it seemed appropriate to make the enclosure in the shape of an artist painting pallet.

This slideshow requires JavaScript.

After using the laser cuter to trace out the shape on cardboard, I needed to use an exato-knife to get it out of the sheet.

The cardboard I found in the recycle bin was double thickness so I cut through the layers in a ring around the holes to mount the translucent material that will allow the LEDs to shine through.

This slideshow requires JavaScript.

Two layers of clear plastic sheet with two layers of white tissue paper sandwiched in between gave me the appearance I was looking for. Trace and cut out pieces that fit into the recesses.

Created an inner structure with shallow cardboard tubes that give space for the Red board, power pack, and house the potentiameters and LEDs.

I found that one LED wasn’t bright enough to light up the little pods, so just wired two together using small proto boards to consolidate the wires.

then added the potentiometers threading the wires in through opposing sides to give it some support and to make sure the LED wires don’t touch it.

Cut a hole in each white plastic piece and then mounted them into the pallet with the pot/LED pods, securing with hot glue.

I wanted some unique knobs for this that looked like blobs of paint, so I made some using some modeling foam and craft paint.

Adding all the wiring in was a bit messy, so I combined all the power and ground wires on proto board, and made sure to label each wire as I went so that hooking up the microcontroller would be easier.

This slideshow requires JavaScript.

Here is a rough attempt at a schematic of the wire hook up:

Final step for components was power. I have a 5v power pack from a previous project that happened to fit, so added that. Also added a rim so that when the bottom piece is attached, none of the internal components show.

IMAG1320.jpg

I’m quite happy with this as prototype. The lighting quality isn’t quite as good as I hoped, but different types of LEDs could solve this if I had a longer time frame to research and experiment.

IMAG1324

https://giphy.com/embed/deDsa6TeLfxnD31fw5

In daylight, the lights are more difficult to visualize, so I put it on the floor under the table so it would show up brighter.

https://giphy.com/embed/9uITi0CHz9a1SYqZFG

Here is the code:

Digital I/O

Part 1:

“Solder a circuits from Monday to a prototyping board (2 leds in series or parallel).”

For part one, I remade my in series circuit by soldering all the components to a small perf board.  The result was a cute little breakout board with three tiny green LEDs, one 100 Ω resistor and a tiny button.  Simple but useful

This slideshow requires JavaScript.

Part 2:

“Build a circuit with 2 or more digital inputs. Use LEDs (regular or RGB) or neopixels as outputs. Program your microcontroller so that each input has a unique output.”

Parts: micro-controller, breadboard, neopixel strip, button, switch, LED, resistors.  

My idea was to have a circuit that has an “on/off” toggle switch and a button that, when pressed, lights up a green LED and changes the light animation from  slow blinking blues and purples (Chill mode) to brighter flashing reds and yellows (Burn mode) on a neopixel strip.

IMAG1241.jpg
schematic showing hook up of micro-controller, two switches, one LED, and a short RGB LED neopixel strip.

I had a bit of trouble getting the buttons to work at first, but then our instructor pointed out I was missing part of the code.  After working out that hang up, I was able to get my light components up and running.  I like working with the ALA (Arduino Light Animation) Library.  This library has some nice “twinkly” options that I’ve really enjoyed using in other projects, and it is easy to add to the Arduino IDE.

Test of the button and toggle with green LED

IMAG1240.jpg

Here is the code:

Final video