Development

Automatic Sensor Source Code Generation

Automatic Sensor Source Code Generation

At the same time as I’ve been trying all kinds of different approaches to sensor material and attachment (including paint, glue, wire, thread, tape, and fabric), I’ve been working on customization and efficient touch sensor test code as well. In a post quite a while ago, I mentioned that after spending some time figuring out all of the ergonomically possible combinations of touches, I actually came up with many hundreds of unique possibilities—a lot more than I’d anticipated.

As you might guess, it’s not very easy to work efficiently with hundreds of unique tests in the source code, especially after I came across a couple of base 1-to-1 combinations that I’d missed before. Making one slight change to the foundation of the system results in a tremendously complicate series of changes all through the code. I have to keep track of which pins correlate to which sensors, which base combinations exist, which complex combinations exist, and which order to check each of them in.

This last consideration has been the most difficult. I spent a few hours this past Wednesday working on the touch priority, and while it wasn’t difficult to do for the base combinations, to became extremely complicated as soon as I started to get into the complex ones.

So, I created a PHP script to automate the entire sensor code generation process. I realize that a PHP script may not be a good final solution, but I chose that approach because I use the language every day and it’s very easily accessible to me. I don’t know if web-based Keyglove configuration will be possible in the future, but if not, I can at least port it to other languages.

Anyway, the basic idea of the script is to use the sensor array, the base combinations, and a fun set of “impossible combination” arrays to build everything automatically. This takes care of literally all of the code necessary to paste into the Arduino IDE. On top of that, the PHP script also builds only the combinations needed for whatever touchset you want to define. That means smaller, simpler, more efficient code.

One of the problems I’ve had is in figuring out how to have the minimum possible code while still allowing touchset customization. It is possible to have a very flexible array list or hash table using pure Arduino code, but for a limited hardware scenario like the Arduino, it’s a bad idea to use dynamic memory allocation and complex data types all over the place. It can seriously slow down the process. So, for the moment, I’m relying on hard-coded sensor control. Actually, except for the touchset portion, the hard code this script generates is perfectly acceptable in any situation. I’d like to make the touchset code more dynamic, but that can wait for now.

The most complicated part of the script of the set of of “impossible combination” arrays. It is an associative array with one keyed element for each base touch combination, and each of those elements contains a list of other base touch combinations that are impossible while the element’s key touch combination is active. For example, the “AY” combination (index tip to thumb tip) would include “Y1” as an impossible combination (thumb tip to top of palm). Obviously, you cannot touch your index fingertip and your palm both at the same time with your thumb tip—unless you are freakishly double-jointed, anyway, and even then not in a very controlled and repeatable fashion.

The rest of the script uses a recursive build function and a few convenient features of PHP to directly create all of the code, complete with the correct touch test order. It’s beautiful. And, more importantly, it will save me hours and hours of time and lots of frustration trying to figure out everything manually.

I hope to have a good test video up within a week showing some real typing with the glove. That, of course, is contingent on finishing a good Prototype B. I’ve been trying so many different things lately that I think maybe I ought to take a few hours and simply build something that fundamentally works even if I’m only 80% satisfied with it. The last 20% will come later.

Conductive Glue Tests

Conductive Glue Tests

If you want the short version, here it is: unfortunately, I haven’t found a good way to use conductive glue yet, either for sensors or for sensor wire attachment. For more info, read on.

I’ve been occupied with all kinds of stuff for the last couple of weeks, which has made it difficult to keep up with posting new blog posts here. However, the project hasn’t been entirely dormant; as promised, I finally got the last of the conductive glue ingredients (carbon graphite powder), and I’ve tried a few different mixes to see what would happen. For reference, I started using the instructions and recipe here.

The first thing I noticed when trying to prepare the glue is that the graphite powder is extremely messy if you are not extraordinarily careful with it. It’s about as bad as laser toner, if you’ve ever messed with that. The powder is extremely fine and tends to “spray” all over the place, almost as if a pile of the stuff has some elastic properties. This was most noticeable when I dipped the measuring spoon into the container and tried to scrape off the excess. It ended up creating a nice scattered blanket of black powder all over the paper towel I used as a workspace cover.

I tried to measure the correct amounts of graphite and Liquid Tape, and immediately after I started stirring them together, I had doubts about whether I added enough Liquid Tape. It just seemed too dry. However, I have the same doubts every time I add a tiny amount of milk to a rice seasoning mix when I’m cooking (which is not often), so I guess I should just learn to trust the recipe. After I mixed it around for about 15 seconds, it really started to become a homogeneous paste, almost the consistency of cake frosting but nowhere near as tasty. (No, I didn’t try eating it.)

As you can tell from the photos, I used a ceramic evaporation dish and a small glass stirring rod to mix everything up. These materials were easy to get from Amazon and eBay, and I knew they would work even with harsh chemicals. Applying the newly mixed glue paste with the glass rod was a little bit of a challenge though. It’s kind of like buttering a piece of bread with a fork instead of a knife—you just get the feeling there has to be a better tool. Even so, it did get the job done, though the glue paste was very sticky. I tried a few different tests for comparison: (1) an entire sensor made from the glue mix, (2) attaching a sensor wire to conductive fabric using the glue mix, and (3) attaching a sensor wire to conductive fabric using pure Liquid Tape. Then I set the glove down to dry and then spent the evening doing something else for a couple of hours.

A note about cleaning: the carbon graphite powder is incredibly fine (it’s actually used for lubrication in some applications). Just try not to get it on anything you don’t want it on or you can’t throw away. It’s virtually impossible to remove it completely. The Liquid Tape is a nasty black goo, but it cleans up well enough with different solvents. You can use paint thinner if you want, but I used regular rubbing alcohol and a lot of pressure. It eventually came entirely off of the ceramic dish, glass rod, and my fingers.

After the glove had a chance to dry, I tried testing the conductivity of each of the three test scenarios. The conductive glue mix was electrically suitable both for attaching wires to other material and for touching two pieces of glue together (i.e. as sensor material, not just wire attachment material). However, it is physically unsuitable for two reasons: it becomes hard and crusty when it dries, and it doesn’t hold wires inside very well. In order to be really useful and well-suited to the task, it needs to be smooth and flexible after drying, and it needs to hold wires reasonably well. If a wire can become detached without a tremendous amount of force, then it’s a serious point of failure, especially when there is no good way to re-attach a sensor wire. Another significant problem is that the conductive glue in hardened form does not work well when used on a capacitive touch screen. This is a key benefit of using conductive fabric, since it is likely that a glove like this will be used in the context of a mobile device more often than not.

The pure Liquid Tape sensor wire attachment looked and felt nice enough (smooth and flexible), but was unfortunately not conductive. I didn’t really expect that it would be, since Liquid Tape is sold as an insulator, but I figured I would give it a try anyway. No luck there. Additionally, it’s not designed to hold things tightly, so it wasn’t that difficult to simply pull the wire out.

I tried again later with a different mix, that time using less graphite than Liquid Tape (probably 0.75:1 ratio). For logic signal detection, it’s okay if I have a few hundred ohms of resistance, since the connection can still be detected. I also mixed a much smaller quantity, since during the first test I ended up with at least five times as much as I needed. I tried the same tests, and found something that essentially performed the same as before electrically, but was only slightly better physically. The glue dried a little less hard and crusty, but nothing at all like the conductive fabric. It wasn’t really flexible, and still didn’t work at all with capacitive touch screens.

A couple of days later, after a stop by the hardware store, I tried another mix (Mix #4 from this page, a follow-up Instructable from the author of the first one linked above). This one used DAP contact cement instead of Liquid Tape. In short, this ended up being yet more flexible after drying, but was not notably better than the first two experiments above. In addition, DAP contact cement smells awful and retains some bad odor even after drying. This mix still didn’t come anywhere near the look, feel, or effectiveness of the conductive fabric. Interestingly though, it did perform a little better than the two previous experiments when testing with a capacitive touch screen. Still nothing like the fabric, but better.

So, I’m still looking for different alternatives. In the mean time, I think I am going to keep the conductive fabric approach for testing and work on the controller software for a little while. If I have any new hardware approach ideas, I’ll be sure to give them a shot though.

VIDEO: Data Visualization

Yet another new video demonstrating more refined accelerometer cursor control:

Keyglove #03 – Data Visualization from Jeff Rowberg on Vimeo.

This video demonstrates the massively updated Processing sketch that I am now using to test the glove’s sensors. It relies on serial data flow for everything and connects directly to the Arduino’s virtual COM port, making it unsuitable for a finished product (you’d want a true HID-compatible connection). However, with this tool, you can very easily see everything about the glove’s current condition to test things like touch sensitivity and mouse control.

I have temporarily postponed the PS/2 interface tests while I work on the core of the glove functionality. Now that I have a reliable test tool, the PC interface is not necessary for continued development and testing. Obviously, it will be eventually, but I’m not going to focus on that right now. The Processing sketch will do nicely until everything else is working well.

For anyone interested, that visualization program is available from the repository, and of course the Processing IDE is open-source and available here.

VIDEO: Accelerometer Tests

New video demonstrating accelerometer cursor control, complete with jitter reduction:

Keyglove #02 – Accelerometer Tests from Jeff Rowberg on Vimeo.

Although the real mouse interface isn’t working, I’ve rigged up a Processing sketch to graphically represent the same movement that will be affecting the mouse cursor once I get that part working. This means I can at least test the accelerometer code I have.

This test shows raw input control from the accelerometer, followed by 5-point averaging, then 20-point averaging, then graduated averaging depending on speed. The idea is to make the movement very responsive if you’re moving it quickly, but much less jittery if you’re trying to hold it in one place. Therefore, it averages only 5 points (fast) during quick movements, but averages 20 points (precise and still) during very slow movement.

This video demonstrates the “tilt translated to position” approach described in the previous blog post.

I’ll be making that Processing sketch available in the Google Code repository after I make a couple more tweaks to it. That should be extremely useful for testing the whole glove without any specific hardware interfaces in place. I want to add a raw accelerometer reading graph, 3D tilt display, and of course regular touch displays as well. Processing is pretty awesome, really.

Incorporating an Accelerometer

The accelerometers that I ordered from SparkFun arrived late last week. I got two of them: one analog (ADXL335) and one digital (ADXL345). The analog one is supposed to be much simpler to use, and it’s a little bit ($3) cheaper, but the digital one requires less power, is less prone to errors, and has more features (including a 0g detection interrupt). I ordered the analog one, then decided to give the digital one a shot even though they said it’s more complicated. I considered cancelling the order for the analog one, but I realized that I’d really like both so I can see the differences in capability first-hand.

So, all that being said, I tried to make the digital one work first, because I know I’ll be able to make the other one work. I do love a challenge.

It turned out to be much easier than I was afraid it would be, thanks to detailed information from Euristic at Live Fast, Code Young. With his code and instructions (with slight modifications for the Mega board pin differences), I had a test program reading data from the accelerometer in 10 minutes of effort. Amazing.

The ADXL345 has a total of 8 pins on the breakout board, which are labeled GND, VCC, CS, INT1, INT2, SDO, SDA, and SCL. For my purposes (and the test program), it is safe to completely ignore INT1 and INT2. Connect GND to the Arduino board ground (obviously), and VCC to the 3.3v pin (not 5V, this can damage the accelerometer). Short CS to VCC right on the breakout board, and solder a small jumper wire between GND and SDO. Finally, plug SDA and SCL into pins 20 and 21 respectively of the board. Note these pins are specific to the Mega; on other Arduino boards, SDA and SCL are analog pins 4 and 5 respectively. With this arrangement and the source code on the above linked blog, I had a steady stream of data flowing in.

Euristic’s schematic has two 10k resistors acting, I believe, as pull-ups from VCC to SDA and SCL. I am honestly not sure what their purpose is, since the behavior seems to be the same whether they are there or not. I left them in though.

After getting the device to work using Euristic’s code, I switched over to the slightly cleaner and more complete ADXL345 library from user kstevenard on Google Code. It works the same and has methods to make use of all the settings available on the accelerometer.

Next, I wrote some code that converts the measurements into angles for each axis. It isn’t perfect, but it’s certainly pretty close. I think a sharp movement would generate unusable data, but we’ll see. I’m still trying to get the PS/2 mouse code to actually move the mouse on my computer; it’s giving me a lot more trouble than the keyboard code did. I figured it would just work since I have the active PS/2 adapter and everything.

Types of motion detection

However, there’s another conceptual problem to solve here: how exactly should your physical motion be translated into mouse movement? There are three main approaches here, and I’ll try to explain each. Two are tilt-based, and one is movement-based.

First, tilt translated to velocity is where the speed of cursor movement matches the steepness of tilt. This is kind of like the way the Trackpoint mouse on ThinkPads work, and it’s also kind of like how a game console controller works (imagine moving a small hand or crosshairs around using the D-pad). Interestingly, I love the Trackpoint, and I can’t stand D-pad cursor movement. I think the Trackpoint must be implemented extremely well, but I know it’s still something people have to get used to.

Using this method is simple to understand but difficult to master with precision. You have to speed up and slow down the cursor at just the right moment in order to “land” on the desired target. It’s very easy to overshoot (or undershoot). It would feel something like the cursor is a marble on a table, and you have to tilt and then re-balance the table at just the right moment. Personally, this sounds terrible to me for normal cursor movement. On the other hand, if you wanted to use the tilt of your hand to control lateral movement in a 3D game, you might prefer this method.

Second, tilt translated to position is where the cursor position changes directly based on the orientation of your hand. If you turn your hand to the right and leave it there, the cursor will move to the right and stay there. In contrast to the previous method, it won’t keep moving until you make your hand level again. This movement can be tracked on any axis. This seems much more intuitive to me than the previous option for normal cursor movement.

The downside of this approach is that you can only rotate your hand about 180 degrees left/right and more like 90 degrees up/down. This means one of two things: either the range of motion would have to be calibrated so you could reach all edges of the screen through one full sweep of each axis, or else you would need a way to temporarily disable motion while you reoriented your hand.

This second “fix” is much the same as when you’re using a desktop mouse and you run out of space while moving across the desk, you simply pick up the mouse (to prevent backwards movement) and put it back down on the desk so that you have more room to move. Most of us do this without thinking about it. For this reason, I believe a similar solution could be used in the Keyglove, perhaps by having a simple “hold” touch combination that would leave you in “mouse” mode but prevent any motion. Then, when you release the “hold” touch, you would be free to continue moving.

Third, movement translated to position is where the speed of the cursor movement matches the speed of your hand movement. This is the easiest to implement in the code, but requires a lot more effort and available space. It does feel very Minority-Report-esque though. Essentially, if you move your hand up and down, the cursor moves up and down with it. Left and right movement function the same way. The downside of this approach is that you need more room to move around, it’s far more visually distracting, and it is also far more physically demanding than the alternatives. It might be nice for a vigorous presentation though. I would think that if you can master the first or second approaches using tilt (which are much more subtle by definition), there’s no reason you’d ever want to use this approach—at least not for mouse cursor movement. Obviously, movement-based gestures could still be very valuable.

So what’s the plan?

I want to build support for all three of these methods into the glove code. Maybe there can be three different “mouse-on” toggle combinations, one for each method, so you can switch between them as you wish. All three methods should have a temporary “hold” combination (like picking up the desktop mouse off the desk).

Now If I can just get this PS/2 mouse emulation code working, I’ll be able to really test it out.

Build Process Changes

Build Process Changes

As I mentioned in my last post, I had a few trouble spots while working with the sensor lead wires. They’re more stiff than they should be. More importantly, in testing each sensor combination, I found that some which should have been easy were actually difficult due to where I placed the sensor(s) in question, and some sensors were much larger than the optimal size. My current prototype glove isn’t even complete—it’s still missing the three large palm sensors and the whole accelerometer setup—but already, I’m making plans for the second glove. In fact, I will probably just leave the current glove as it is and wait for the new test materials to arrive (they’re all already ordered).

I realized that a significant revision was necessary when I made it (mostly) to the end of the glove assembly process, and although it was exciting and gratifying, my main thought was there has GOT to be an easier way to do this.

Obviously, since this was my first attempt ever, I can’t really complain about how long it took. I had to figure a lot of stuff out as I worked, and that approach is always slower. Doing the exact same steps (at least the ones that weren’t part of a test that failed) will presumably take much less time on the second attempt. However, as I thought about the complicated and/or time-consuming parts, I concluded that some parts of my current build process are not very efficient.

I have outlined below the process that I used to build the glove (called Prototype A) the first time, starting from all of the raw materials. This is followed by a hardware list and build process for my next prototype (called Prototype B). Prototype B will also include an accelerometer, but I haven’t listed it or the steps required to implement it here because it wasn’t part of Prototype A, and the main point here is to contrast the changes to the process between Prototype A and Prototype B. The accelerometer steps, at this point, would be the same in both cases. These lists also exclude the PS/2 interface hardware. Only the hardware for the glove-to-Arduino interface is listed here.

Prototype A Hardware

(note: don’t use this one as a shopping list)

  • Right-handed cotton handbell glove w/strap
  • Arduino Mega board and USB A-to-B cable for programming/testing
  • Approx. 25 sq. in. of conductive fabric
  • Approx. 50 ft of solid black 26 AWG insulated wire
  • 34 unsoldered male header pins
  • 5 different colors of 3/32″ heat shrink
  • Wire glue
  • 5-minute epoxy
  • Needle, thread, and sewing pins

Prototype A Build Process

(note: don’t follow these directions exactly)

  1. Cut 34 separate 18-inch lengths of solid black wire for sensor leads
  2. Strip ~1/8″ of insulation from both ends of all 34 wires
  3. Solder a male header pin onto one end of each of the 34 wires
  4. Use scotch tape to secure the non-pin end of each wire to a flat surface
  5. Cut best-guess sizes of conductive fabric for sensors
  6. Place each sensor fabric piece carefully on flat surface under each exposed wire end
  7. Mix up wire glue with a toothpick for best consistency
  8. Use toothpick to apply very small drop of wire glue to the exposed part of each wire, allow 30+ minutes to dry
  9. After at least 30 minutes, mix batch of 5-minute epoxy and apply slightly larger drop to wire glue/fabric to ensure total coverage and strength, allow 15+ minutes to cure
  10. Cut 12, 12, 5, 3, and 2 sections (respectively) of five chosen colors of heat shrink (1/4″ or 3/8″ length is fine)
  11. Slide heat shrink over header pins and secure with lighter or other heat source
  12. Place each sensor on the glove in its best-guess location and secure with either 1 or 2 sewing pins as necessary
  13. Cut appropriate lengths of thread and sew each sensor on, maintaining position and alignment as much as possible
  14. Gather sensor lead wires into groups by finger and loosely tie together with small wire sections
  15. Sew strategically placed loops around each wire or bundle of wires to make sure they are firmly attached to the glove and will not move independently
  16. Connect Arduino board to computer, run IDE, and upload the Keyglove controller code
  17. Insert each sensor wire header pin into the appropriate I/O receptacle on the Arduino board
  18. Test all basic 1-to-1 combinations for success

Now, if you actually took the time to read through all that, you might notice a few things (particularly about the build process). First, some of those steps could be done in almost any order. Obviously you can cut the lengths of heat shrink whenever you want, as long as they are available when you need them. You could attach the wires to the fabric before you solder the header pins to the other end. This is true, and any changes I’m suggesting below that affect those arbitrary tasks are coincidental.

Second, you might notice that some of those items take only a minute, while some take many hours—especially #8 and #9 for attaching wires to sensors, and #12 and #13 for sewing the sensors onto the gloves. These are the major areas of difficulty, and any improvements in those parts of the process will have a significant effect. That is my goal at this point.

Although the above list of steps is pretty straightforward, in reality I didn’t exactly do things in precisely that order. I did them piecemeal, especially the sensors, as I was testing what worked and what didn’t. If I had all the materials in front of me right now and I followed that process from beginning to end, I estimate it would take me about four hours, with the bulk of the time spent sewing. Even with an improved process, this time isn’t likely to change much.

However, while it might take time, it doesn’t have to be hard. Tedious, maybe, but not hard. Here are the three main aspects of the Prototype A hardware and build process that make things harder than they should be:

  1. PROBLEM: Solid 26 AWG wire.
    I thought this would be thin enough to get the job done, but it’s still stiff. It looks fine once you get it all pinned down to the glove, but it tends to push against the sensor material while you’re trying to glue them, and when you’re trying to sew them on, and when you’re moving your fingers around while using the glove. The end result is that (1) the you need to be extra precise during the wire attachment step, (2) it is virtually impossible to get the sensors sewed on tight exactly where you want them, and (3) using the glove feels just a tiny bit awkward due to added resistance. Solid wire is just a bad idea for this purpose.
    • SOLUTION: Use stranded 30 AWG wire instead.
      This will give the added flexibility necessary to prevent the wire from exerting significant force on the sensor fabric. The wires are never under a lot of stress, so switching to stranded won’t degrade the durability of the glove either.
  2. PROBLEM: Sewing sensors after attaching the wires.
    Two bad things happen as a result of this: first, the wire hanging off (even the stranded wire, to an extent) tends to pull in some direction on the sensor fabric while you are trying to sew it on. This causes it to shift unless you are incredibly good at sewing, which I am not. Second, because the wire is attached partially using epoxy, it is impossible to sew through the epoxied area on the fabric. This leads to a loose “flap,” usually one particular corner, which is not pinned down and therefore an area of strain and weakness. Any pull on the sensor that comes from the wire puts force primarily on this one corner, which leads to uneven wear and creates a likely point of failure.
    • SOLUTION: Sew the sensors on first, and use a different glue.
      This is still a bit of an unknown for me, and my solution involves more testing before I’ll be confident. However, multiple people have recommended the home-made conductive glue that I’ve linked to above as a possibility for attaching the wire to the fabric. It is conductive and flexible, so they say—a cleverly calculated mixture of ultra-fine carbon graphite power and Liquid Tape. It is remotely possible that it will even work as sensor material, negating any need for fabric, but I doubt it will exhibit the same touch conductivity, and likely also not have the same success with capacitive touch screens. I will experiment with it to find out. The chemicals required are currently on order.

      Changing the sewing/gluing order around will also require another change, unless this new glue possess a magical property that makes it strong enough to hold the wire in place with only a tiny amount. Specifically, I have been gluing the wires onto the back side of each sensor so that the entire front side remains available for maximum touch-sensitive surface area. However, if I sew the sensors on first, only the front side will be available. This means I’ll have to attach the wires onto the front side with the glue. For large sensors, this should be fine. But for the small ones, it could be a problem. Hopefully it won’t use up more than about 1/8″ square of surface area. For a 1″ square sensor, this is is only about 2%, but for a 1/4″ square sensor, it’s 25%. Perhaps if I am very lucky, I’ll be able to reliably attach them to the back side despite the stitches that will be holding each sensor down, but I’m not sure. It is also possible that it won’t inhibit the practical sensitivity of each sensor. I’ll have to find out when the materials arrive.

      One more note: I originally rejected sewing first and gluing second precisely because of the difficulty in attaching wires to the sensors while they are on the glove. However, this was because I was doing it the old way, leaving one corner unattached, and pinning it up while I precariously bent the wire just right so it was touching the fabric. If I use stranded wire and this new glue (which is considerably sticky), and especially if I use the front face of each sensor, these problems will all go away.

  3. PROBLEM: Sensor size and position makes accuracy difficult.
    Part of this is admittedly caused by my relatively poor sewing skills, and this element of the problem will hopefully be fixed by the previous problem’s solution as well as my skill improving over time. However, some of it also comes from the fact that the sensors I cut are just not the right size in many cases. They are generally too large, making it far too easy to touch the wrong one (especially with my thumb).
    • SOLUTION: Pre-cut all sensors to new specifications based on initial results.
      Here is the critical point: sensors that are primarily “targets” should be very small, while sensors that are primarily “initiators” should be large. Sensors that are both can be large as well. The only exceptions are the three very large “target” palm sensors, which need to be large but can be so without creating problems, since they are not near anything else.

      To clarify, when I say a sensor is a “target” or an “initiator,” think about touching your palm with your fingertip. You wouldn’t say that you’re touching your fingertip with your palm, because that’s not what it feels like to you. Your thumb is doing the touching, even though technically they are both touching each other. Fingertips are really the only ones that can be both targets (in the case of the initiating thumbtip) and initiators (in the case of everything else), so they should be large as well. In essence, this means that all of the middle and lower finger pads, the finger sides, and the fingernails should all be very small—probably not much more than 1/4″ or maybe 3/8″ square. The two thumb pads (upper and lower) will be large, as will the four fingertips, and of course the palm pads. The large size of the thumb pads (roughly 1″ square) make it very easy to reach the right little sensor without focusing on precision, and the small size of the target sensors make it very easy to avoid hitting the wrong ones accidentally.

So, those are the problems and the solutions. Here are my hardware and build process lists for Prototype B, which I will start on as soon as the new gloves and stranded wire arrive. Note that I’m still recommending an Arduino Mega board here even though my ultimate goal is to use the Teensy++, because the Arduino board is better for rapid prototyping, at least in my opinion.

Prototype B Hardware

  • Right-handed cotton handbell glove w/strap
  • Arduino Mega board and USB A-to-B cable for programming/testing
  • Approx. 15 sq. in. of conductive fabric
  • Approx. 50 ft of stranded black 30 AWG insulated wire
  • 34 unsoldered male header pins
  • 5 different colors of 1/16″ heat shrink (quite small)
  • Conductive glue ingredients (carbon graphite powder and Liquid Tape)
  • Needle, thread, and sewing pins

Prototype B Build Process

  1. Cut 34 separate 18-inch lengths of stranded black wire for sensor leads
  2. Strip ~1/8″ of insulation from both ends of all 34 wires
  3. Solder a male header pin onto one end of each of the 34 wires
  4. Cut 12, 12, 5, 3, and 2 sections (respectively) of five chosen colors of heat shrink (1/4″ or 3/8″ length is fine)
  5. Slide heat shrink on from non-header side of each wire secure around header pin solder joint with lighter or other heat source
  6. Cut precise sizes of conductive fabric for sensors
  7. Place each sensor on the glove in its precise location and secure with either 1 or 2 sewing pins as necessary
  8. Cut appropriate lengths of thread and sew each sensor on, maintaining position and alignment as much as possible
  9. Mix conductive glue ingredients according to directions
  10. Glue each wire onto the front surface of each sensor, securing with light Scotch tape if necessary while it dries
  11. Gather sensor lead wires into groups by finger and loosely tie together with small wire sections
  12. Sew strategically placed loops around each wire or bundle of wires to make sure they are firmly attached to the glove and will not move independently
  13. Connect Arduino board to computer, run IDE, and upload the Keyglove controller code
  14. Insert each sensor wire header pin into the appropriate I/O receptacle on the Arduino board
  15. Test all basic 1-to-1 combinations for success

There you have it. Hopefully this should speed up the build process and make the whole thing simpler. Now I need to go play with this accelerometer some more while I wait for the rest of the new materials to arrive.

A Mostly Working Prototype

A Mostly Working Prototype

My glove is almost all built! I don’t have a touchset defined yet, but that’s all software and I’m mostly focusing on hardware at the moment, which is definitely the hard part for me. And, in fairness, this is all keyboard and no mouse so far. I have barely touched the accelerometer that arrived today.

Back to the most recent success: even though the full order of conductive fabric didn’t arrive until this afternoon, I was able to cut and attach every piece of sensor material except for the three large palm ones using what I had left over from the small sample I got for testing. I’ve gotten a little better at sewing with only one hand, helped in no small part by the use of pins (visible in the first photo here). If I don’t run into a “tangled thread” situation, I can do one sensor now in less than five minutes. This makes for an average full-glove sensor attachment time of roughly four hours.

After I got everything attached, I set about separating the sensor lead wires into bundles organized by finger. They had been loosely tied according to sensor type (e.g. fingernails, finger pads, finger sides, etc.), but this turned out to be not very logical anywhere except at the I/O header, which is the easiest element to deal with in this whole apparatus. The thumb has three, and the other four fingers have seven each (one nail, three pads, and three sides).

Even separated and regrouped by finger, the wires here are very messy. This is due in part to the fact that it’s solid, even though it is quite thin (26 AWG). It still has enough resistance to keep most of its shape against the force of gravity. As you can see in the third photo, with 34 sensor wires, this creates a huge inconvenient mass of wires—without any extra work, anyway.

The solution to this problem is to secure the wires to their logical paths tight up against the glove. I was originally planning to use epoxy glue beads because it was easy, but it’s also impossible to undo easily. Because of my newfound ability to sew (sort of), I changed my mind and opted to use little loops of thread instead. This resulted in a glove that looks almost exactly how I originally imagined it way back (three weeks ago) when I was mulling over the idea in my head. Awesome!

The only thing I am a little worried about is that my technique for sewing the loops is inadequate. I am worried that they might somehow come undone, and while that wouldn’t be a huge problem, it would certainly be inconvenient. I think I might have to look up some info online for tips on how to more effectively do that kind of simple thread-based tying job. However, it really did turn out quite well—at least as good as I hoped it would.

As soon as I got all of the wires secured and re-bundled, I plugged all of the sensor pins into their respective spots on the I/O header as fast as I could. To my dismay, that ended up being a lot harder than I thought it would because of an practical oversight on my part back when I was trying to be clever by adding colored head shrink to the sensor lead pins. Colored heat shrink for sensor categories is a great idea, but my execution of it was wrong. I had the heat shrink wrapped around the plastic part of the header pin as well as the metal, which effectively adds at least 1mm of width to every header pin.

Each pin doesn’t have a lot of extra room as it is, and adding that much extra makes for a very crowded I/O header. So crowded, in fact, that some of the pins just wouldn’t go in at all. The crowding affect builds up as more pins pile up against each other. I had to take a knife and cut off some of the heat shrink on some of them to get them in. I even cut off the very last pin entirely and just stripped the wire and stuck it in directly.

Naturally, my next immediate desire (at 1:30am) was to try touching each possible combination of sensors together to see how easy or hard each one was. I had already been doing this a little in my quest to find which pin belonged in which hole, but it was quite gratifying to go through all of them and just watch it all work like I imagined it would. However, I will also add here that testing each sensor combination—and, in fact, going through the whole glove-building process—has brought to light quite a few changes that would (will) make in building a second glove. I will get into that in another post shortly.

Working With Sensors

Working With Sensors

It seems that my blog is having a hard time keeping up with the latest developments. I’ll just pretend I can blame that all on the blog somehow and ignore the fact that the author may have something to do with it. Anyway, I’ve been looking into touchset possibilities based on letter frequency, using an accelerometer for mouse control (which is vastly better than what I originally had in mind), and trying to streamline the sensor attachment process. This post will be about the sensors; the other items will have to wait until later.

After I found a good conductive fabric to use for sensors, I set about preparing the sensor lead wires to be attached to the material. While I don’t currently have enough material to do all of the sensors, I still have all of my lead wires from back when I was trying to use copper foil tape. Obviously, I had to cut all of the foil squares off the ends of the wire, which meant I needed to strip another 1/8 inch of insulation off the ends of all 34 wires. Additionally, the wires don’t do so well all by themselves being stuck into the Arduino board female I/O header, so I stripped the other end as well and soldered header pins onto all of them.

Finally, I needed a way to somehow identify the tail end of each sensor lead, so I wouldn’t have to deal with 34 nondescript black wire ends and try to figure out the hard way which one went to which sensor. So, I cut small sections of different colors of heat shrink tubing and secured them around the back side of each of the header pins. The front finger segments are black (12), the side finger segments are blue (12), the thumb pads are red (2), the fingernails and thumbnail are white (5), and the large palm strips are green (3). I will still have to determine which is which among the sets, but at least it will be much easier. Also, for the finished product, the leads should be soldered directly to the controller board. I am only using this header pin approach for prototyping. It makes things much, much simpler visually and physically—not to mention the fact that it makes it easy to rearrange I/O pin assignments without the hassle of re-soldering.

After I got the wire leads all prepared, I cut five pads from the small amount of material I currently have: one for the thumb pad, and four for the top finger pads. I figured that would make for the easiest testing environment. My wonderful fabrically-unchallenged wife sewed the first two pads on to show me how, and then I took over for the last three. It took me 45 minutes to do it, but I got them on eventually, and I’m happy with how it looks and feels.

The thing about sewing something onto a glove is that it is much easier if the glove is in the correct shape—namely, your hand is in it. This is a challenge because this leaves you only one hand with which to sew. It’s an even greater challenge in this case because I’m right-handed, so naturally I’m building a glove for my right hand…so therefore I am left with only my left hand to sew with. Quite challenging indeed. Fortunately, the stitches required to attach the pads are not complicated, and can even be completed with a non-dominant hand if you have enough patience.

The basic approach to sewing the sensors on with one hand in the glove is that you start each stitch going straight down, then stop when you feel the needle poke your finger, then continue laterally under both the sensor fabric and the glove fabric for a quarter inch or so, then come straight back up. If you don’t go straight in or come straight back up (as much as possible, anyway), then you risk having the sensor material shift to one side slightly when your stitches become tight. This isn’t always a terrible thing, but if you want a lot of precision in sensor alignment, it’s good to keep it in mind.

I have also found that it is much easier to attach all of the wires first, and then sew the sensors on. The pictures above show the process involved in attaching the sensor wires after being sewed, and it is definitely harder than sewing sensors with wires already attached. It works best to have all of the wires coming off of the same corner of every sensor, and for my purposes, I’ve chosen the bottom left corner as shown in the photos. Since you can’t very well sew through epoxy, this corner remains relatively unsecured (though the rest of the stitches keep the sensor in place well enough). Using this unsecured corner, it is possible to apply wire glue and then epoxy to attach a wire lead if necessary. The three sensors I sewed here followed that process, but it was not easy by any means. Having a wire attached makes it harder to sew, but it is still easier to do this than to attach the wire afterwards.

One other note: although it isn’t shown in these pictures, it is much simpler to sew the sensors on if you pin them down (literally) with two pins to keep them from moving much once you have them in the correct position on the glove. This virtually eliminates any extra difficulty from the wires being attached already.

After I got the first five sensors sewed on and create the proof-of-concept video, I set about getting the rest of them done. I’ve ordered more of the conductive fabric, though I don’t expect it to show up for a few days, but even just the sample that I got last week has enough to do a few more than the five already done. So, I cut out enough material to do the middle and lower finger pads (B/C/E/F/H/I/K/L according to my diagram), and tried to figure out a good way to attach the lead wires all at once.

One of the difficulties in using wire glue, since it isn’t really all that sticky, is that the unless the wires are positioned exactly in the right spot, they can move easily and create a sub-standard joint (or worse, come out of the glue completely). What I did to fix this problem was use regular sticky tape to secure each wire lead onto a flat surface (I used a piano bench), and then positioned each piece of sensor fabric underneath the ends of the wires. It looks a little funny, but it really works.

Once the wires are in place, it’s easy to apply a small dot of wire glue to each connection. Once it dries (less than an hour, but I let it sit for a couple of hours to be safe since I had somewhere to go that evening), mix up a small batch of epoxy and apply a small bead to the area where the wire glue is. It’s a good idea to get the epoxy to go slightly beyond the wire glue area, since that will let the epoxy hold the entire joint securely to the fabric. If it is only on top of the wire glue, then the wire glue is still the only thing effectively holding the wire to the material, and there isn’t a lot of added strength.

Once again, note the orientation of each bit of sensor material. First of all, the wires are all attached to the concave side (so the material shows a slight tendency to curl up around the wire). This makes it a little easier to mount each sensor to the glove. I believe the conductivity is roughly the same for each side, though I didn’t test to the resistance specifically. I have taken to calling the concave side the “back” of the material, and the convex side the “front.” Also note that since we’re attaching the wires to the back, they should go on the top left (or bottom right) of each sensor. This means that once we flip each sensor over and attach it to the glove, the wire lead can be coming out of the bottom left corner of the sensor. This seems to make the most sense to me, though if you have a reason to do it the other way, it is of course your decision to make.

I still need to sew the rest of these sensors on, now that they have wire leads attached. Hopefully it won’t take too long. I’ve found that I can do the sewing at the same time as watching a series of Doctor Who episodes. The two tasks go together quite nicely, really.

Working Sensor Material and Wire Attachment

Working Sensor Material and Wire Attachment

Well, I’ve finally come up with a good material to use for sensors, and a good way to attach the wire leads to the fabric, and a good way to attach the sensors to the glove. Finally. Here is the short version:

  • Material: stretch conductive fabric (Cat. #251 from LessEMF)
  • Wire attachment: wire glue followed with a bead of 5-minute or 30-minute epoxy
  • Sensor attachment: sewing with regular or conductive thread

Honestly, I don’t think conductive thread is necessary because the material is so incredibly conductive itself. Unless you sew all over the surface with non-conductive thread, you really probably aren’t going to have any problem at all.

I came to the above conclusion about the material because it excels at every single property necessary for touch sensors except solderability. It’s thin, stretchy, easy to sew through, and insanely conductive, particularly when you touch two pieces together. Many of the materials I tested were perfectly conductive between two points on the same piece of material, but pressing two separate pieces of material together didn’t result in an electrical short. Since the glove is entirely built around the concept of touching sensors together, this is obviously a critical problem.

The boringly labeled “stretch conductive fabric” is made mostly of nylon and achieves its conductivity because the nylon is silver-plated. That’s why it so expensive, but as I calculated in the last post, even one linear foot (~$60) of material cut from a bolt of that stuff would make sensors for about 50 gloves. That’s not prohibitive at all, really.

Of course, after deciding to use a fabric that I can’t solder wire to, I had to come up with a way to reliably attach a wire to it while maintaining conductivity. The answer to this problem turned out to be a thin application of wire glue first, and then another thin application of epoxy to add strength. The wire glue is great for conductivity, but very poor at holding something in place under stress.

The perfect joint is achieved by applying only a very small amount of wire glue, since the somewhat porous nature of the fabric actually allows it to flow through to the bottom. You really don’t need a whole lot, since the real work will be done by the epoxy. The wire glue is really only there to make sure the epoxy doesn’t somehow separate the wire from the fabric. After the wire glue is dry (give it an hour or so), mix up a small glob of epoxy and apply a small bead with a toothpick or something similar. Flatter is better, since the thicker it is, the more raised the sensor will be on that corner.

One other note: the fabric is conductive on both sides and through the center. Therefore, I put the wire on the back side to leave the front entirely open for maximum available area. It also looks nicer that way. The fabric has a shiny side (the front) and a less shiny side (the back), and seems to have a slight natural curl such that the front is convex and the back is concave. Hopefully that’s enough info for anyone to figure out which is which. See if you can tell from the picture above.

Now I need to actually try to attach one of the sensors to the glove to see if I can actually do it. The most sew-ish thing I’ve ever done before was a cross-stitch project about 10 years ago. We’ll see how it goes. I was going to try an iron-on double-sided adhesive strip, but the LessEMF fabric description very clearly states “DO NOT IRON.” So I guess that’s out.

Conductive Fabric Performance

Conductive Fabric Performance

The sampler pack from LessEMF arrived in the mail today, so naturally I was very eager to test the performance of the samples. The pack includes 16 different kinds of material. I don’t think I need to look at all of them in detail, but I will anyway just for the purpose of being thorough, and because I’m curious. For technical details on the different materials or to purchase some, go to LessEMF’s fabric page. It’s not expensive in small quantities.

In order to determine the suitability of using each material for Keyglove sensors, I’ve come up with a list of tests. Not every one of the tests must to be successful, but the more that are, the better the material will be considered. Here is a summary of each different test, in order from most to least critical:

  • Conductivity: it must have very high electrical conductivity so as to create a short when two pieces are lightly touched together. No pressure should be required. This test involves checking for a short between two points on the same fabric, and then again by holding wires against two unique pieces and touching only the fabric together (to simulate the glove action).
  • Flexibility: it must bend easily so that any finger position will not feel inhibited due to the material. If it is too stiff, the glove will feel unnatural and be unpleasant to use.
  • Solderability: it must be able to have a wire lead attached somehow. Depending on the rest of the tests, if this fails it may be possible to use conductive thread or silver epoxy to get the job done. Solder would be preferable for ease though.
  • Sewability: it must be able to attached with some kind of thread to the cotton glove base. Material that is too thick or dense may resist too much. Material that is too weak may pull away or tear from the stitches.
  • Phone Tap: it must be able to accurately register a single tap on a capacitive touch screen (such as on an iPhone). This should feel exactly the same as using your finger would and require no more pressure or precision.
  • Phone Drag: it must be able to accurately register a tap-hold-drag motion on a capacitive touch screen. Again, it should feel exactly like using a bare finger.
  • Elasticity: it must stretch at least a little bit to accommodate certain hand positions more easily. This won’t matter for most sensors, but could be useful for the long ones placed on the palm.

Below is a detailed list of how each of the sampler materials performs under the tests outlined above. One test that I cannot perform well is long-term durability, which is certainly important, but impossible to test quickly. I will have to see how my “best choice” material holds up after I start using it on the glove. My current favorite, the stretch conductive fabric, has a very fine silver coating (which contributes substantially to its cost) which they say will come off after repeated washings in hot water. I wonder if it might come off under other circumstances as well.

Also, note that when I label a particular material as “suitable” or “unsuitable,” I am referring only to the suitability as a Keyglove sensor, and not to the suitability of its intended purpose. I have no doubt that these materials do not behave electromagnetically exactly as they are represented by LessEMF.

Quick verdict: one of Stretch Conductive Fabric, VeilShield™, or Canopy Mesh Fabric depending on budget and wire mounting capabilities. Read on for more detail.

Stretch Conductive Fabric (suitable)

Conductivity Excellent.
Flexibility Excellent.
Solderability None, but a wire can be “melted” into one side.
Sewability Excellent.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity Excellent.
Notes Melting wires into the material is, I’m sure, not what LessEMF intended. However, it does appear to make a solid, reliable electrical connection between the wire and the material. The melted nylon lets of what is probably a small amount of toxic fumes, and it changes the dark gray coloration to be a burnt brown/orange color immediately around the wire tip. It also grips rather tightly to the wire (a consequence of melted nylon). I tested the strength of the hold, and it took quite a lot of pull to remove the wire. I tried re-melting it to another spot and then added a small dot of 5-minute epoxy to test again. It may be possible to achieve the conductivity with epoxy only and skip the melting.

Knit Stainless Steel Mesh (unsuitable)

Conductivity Excellent.
Flexibility Excellent.
Solderability None.
Sewability Excellent.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity Slight.
Notes This is a relatively coarse wire mesh, and if pulled slightly it will return to its shape. However, if pulled with substantial force, it will simply bend the interlocking mesh links, and it will be forever stuck that way. The main problem is that it is 100% stainless steel, and I could not get any solder to meld properly. The canopy fabric below is basically the same but can be soldered.

Canopy Fabric (suitable)

Conductivity Excellent.
Flexibility Excellent.
Solderability Excellent.
Sewability Excellent.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity Slight.
Notes Since this material is nothing more than tin-coated copper wire, it is very conductive and easy to solder. I worry that it might have damaging effects on extremely smooth surfaces like car paint. This stuff exhibits the same elasticity properties as the knit stainless steel mesh above (though less force is required to permanently bend the mesh since the material is thinner). It is actually solderable though, in contrast to the stainless steel mesh.

Ex-Static™ (unsuitable)

Conductivity None.
Flexibility Excellent.
Solderability None.
Sewability Excellent.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity Very slight.
Notes This fabric isn’t conductive at all between two pieces or from point to point on the same surface, so it doesn’t much matter. However, I was surprised to see the phone tests work correctly.

Pure Copper Polyester Taffeta (unsuitable)

Conductivity Poor.
Flexibility Excellent.
Solderability None.
Sewability Good.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity None.
Notes This material is, like others, conductive between two points on the same surface, but not between two different pieces of material. It is also not solderable. It is quite dense, which would make it a little harder to sew, but not impossible.

Nickel/Copper Ripstop (unsuitable)

Conductivity Poor.
Flexibility Excellent.
Solderability None.
Sewability Good.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity None.
Notes This is almost the same as the copper polyester, only it has nickel as well and it a tiny bit less flexible. The effective conductivity is identical.

ShieldIt™ Super (unsuitable)

Conductivity Poor.
Flexibility Good.
Solderability Decent wire attachment possible, but weak.
Sewability None.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity None.
Notes The conductivity is actually excellent on the same surface, but terrible between two pieces. This material has a hot-melting adhesive backing which might have made it very easy to attach to the glove. However, since the conductivity test didn’t pass, it’s kind of pointless to try. Also, the soldered wire lead did stick remarkably well, but due (I assume) to weakening of the fabric by the extreme heat, the small area with solder on it actually broke away from the rest of the fabric after some force was applied. This didn’t happen very easily, but easily enough that I would worry about the reliability of the attachment through daily use.

Bullionet™ Mesh (suitable)

Conductivity Excellent
Flexibility Excellent
Solderability None.
Sewability Excellent.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity None.
Notes This material looks very much like what is used for window screens. The mesh has a square pattern. It’s conductivity is good, but it falls apart under the soldering iron. The side of the mesh makes sewing very easy, and it works well with phones. Given other options though, I’d probably go with the VeilShield™ over this.

ArgenMesh™ (unsuitable)

Conductivity Poor.
Flexibility Excellent.
Solderability Poor.
Sewability Excellent.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity None.
Notes Like some others, this material’s conductivity is excellent on the same surface, but not reliable between two pieces. I believe this material has too much nylon (45%) arranged in such a way that the metal is not always right at the surface. Some of the touch conductivity tests didn’t seem to work well. Soldering made the wire grip the material at the cost of destroying the nylon holding it all together. I’d pass on this stuff, since there are so many other good options.

Soft&Safe™ Shielding (unsuitable)

Conductivity Poor.
Flexibility Excellent.
Solderability None.
Sewability Excellent.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity None.
Notes This stuff is unique because it uses bamboo for the non-conductive part of the material. It was very resistant (by comparison) to heat damage during the solder test. The conductivity is good between two points on the same surface, but not at all between two different pieces.

StatiCot™ Shielding (unsuitable)

Conductivity Poor.
Flexibility Excellent.
Solderability None.
Sewability Excellent.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity None.
Notes This material is made of polyester, cotton, and stainless steel. Soldering is pretty much impossible. The conductivity is not at all good enough for what I would need for a sensor. It is only 25% non-fabric material, and thus looked the most like regular fabric of all of the samples.

RadioScreen™ (suitable)

Conductivity Excellent.
Flexibility Excellent.
Solderability None.
Sewability Excellent.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity None.
Notes This stuff looks and feels great. However, soldering doesn’t work at all. In fact, it seems to destroy the woven mesh wherever the heat is directly applied. It may be possible to “weave” the wire lead into the very fine mesh and then secure it with an epoxy bead. One other note is that this material is nickel-plated and possibly unsuitable for people with extreme nickel allergies (LessEMF’s warning).

VeilShield™ (suitable)

Conductivity Excellent.
Flexibility Excellent.
Solderability None.
Sewability Excellent.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity None.
Notes This is very similar to the RadioShield™ stuff above, except the mesh is even finer and the material is thinner. It is nearly transparent as well, which is kind of neat. Soldering is still not possible.

CobalTex™ (unsuitable)

Conductivity Poor.
Flexibility Excellent.
Solderability None.
Sewability Good.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity None.
Notes This material is almost the same as the the copper polyester and nickel/copper ripstop, except it has a nickel-cobalt alloy coating. The rest of the effective qualities are identical.

ESD Static Fabric (unsuitable)

Conductivity Good.
Flexibility Excellent.
Solderability Possible, not great.
Sewability Excellent.
Phone Tap Acceptable.
Phone Drag Acceptable.
Elasticity Slight.
Notes This material has a tendency to “catch” on itself or other nearby fabrics due to the ends of tiny wires in the mesh being exposed after cutting. This could make it slightly annoying to deal with depending on your sewing skills (mine are quite poor at this point). Soldering is possible, but the interwoven fabric inhibits a very clean joint. I would probably rather use one of the non-fabric pure fine meshes instead of this.

AL100 Wall Shielding (unsuitable)

Conductivity Poor.
Flexibility Poor.
Solderability None.
Sewability Poor.
Phone Tap Excellent.
Phone Drag Excellent.
Elasticity None.
Notes This material is definitely not suited to be a Keyglove sensor. It’s designed to be EMF wall shielding. I say it has poor flexibility not because it is especially stiff, but rather because it is flexible in somewhat of the same way that a thick piece of aluminum foil is flexible, but not at all like fabric. It is too thick to sew, and there is a plastic-like coating on the back surface that melts easily when attempting to solder. This is just a bad choice for the Keyglove.

So, there we have it: a full run-down of the suitability of each type of sample material. Here are the results in a summary format:

  • Only 5 out of the 16 materials could be used for sensors:
    • Stretch Conductive Fabric ($59.95 per linear foot)
    • Canopy Fabric ($15.95 per linear foot)
    • Bullionet™ Mesh ($11.95 per linear foot)
    • RadioScreen™ ($15.99 per linear foot)
    • VeilShield™ ($18.95 per linear foot)
  • Almost none of the materials are solderable (of the above, only the canopy fabric)
  • Almost all of the materials work on capacitive touch screens
  • If capacitive taps work, so do capacitive drags

The “linear foot” prices are from spools of fabric that are typically at least 42 inches wide, so one linear foot is actually at least 500 square inches. Since each glove requires approximately 10 square inches of sensor material (estimated), that means that one foot can do 50 gloves, meaning even the really expensive stretch conductive fabric comes out to be $1.20 of material per glove. Not too bad.

Given all the possibilities, my favorite is the stretch conductive fabric. I only need to find out what the best way of attaching a wire lead to that material is. I’ve sent an email to the people at LessEMF to see if they have any recommendations, and in the mean time, I’m going to try some experiments (involving cheap wire glue and/or epoxy beads). I’d like to avoid using silver epoxy, though I know it would work, because it would greatly add to the cost of any glove—probably as much as $10 per glove, realistically. With 34 sensors, 14 oz. of epoxy goes pretty quick.

Page 4 of 512345