Jennifer Blight

Automated Gardening

Wed, 27 Feb 2019 00:00:00 +0000

So it turns out that I am too lazy to water my plants, but not too lazy to spend many hours automating the watering of my plants.

I started working on this project after all my plants died when I went on vacation. It currently waters the plants once per day and monitors the soil moisture. The moisture sensors, as it turns out, aren’t sensitive enough to determine the watering schedule but they make for a nice graph.

The full list of materials is:

Arduino Uno
WiFi Shield - ESP8266
3 Soil Moisture Sensors
3 12V Solenoid Valves
3 TIP120 Darlington Transistors
3 Kickback Diodes
DROK LM2596 Switching Regulator
12V 35 PSI Water Pump
3/8” ID Tubing
3/4” ID Tubing
3/8” T hose connectors
3/8” - 3/4” hose adapters
Bunch o’ hose clamps
Teflon tape
Plants

The easiest portion of this is the moisture sensors. Each sensor has three terminals: power, ground and signal. The sensor lasts longer if it’s not powered all the time, so we power it from an output pin. Every half-hour, we set the power pin to high, read a value from each sensor and make a request to a Flask app.

The actual watering was harder. The valves only work properly when pressurized and both the valves and the pump require 12V. Using a switching regulator, we can have a 12V rail for the pump and valves and a 5V rail for the Arduino. The pump can be connected directly to the 12V rail; it will itself turn off when the system in pressurized. The valves are controlled with TIP120 transistors.

The tubing required a lot of trial and error. The pump output is significantly smaller than the valve inputs and needs to be stepped up with a 3/8”-3/4” adapter. The hardware store didn’t have all the fittings I needed, and I had to combine connectors in a few places. All the connections need to be wrapped in teflon tape and clamped down tightly to maintain pressure. I spent a couple hours turning the system on, finding a leak, tightening the clamp, finding a new leak, etc. Also of note: when the pump is first turned on, all the valves need to opened until there is no air left in the tubes; any air pocket in the tubes will be compressed and eventually pop as the system pressurizes.

Code

#include <SoftwareSerial.h>
#include <SparkFunESP8266WiFi.h>

//////////////////////////////
// WiFi Network Definitions //
//////////////////////////////
const char mySSID[] = "<wifi>";
const char myPSK[] = "<wifi password>";

//////////////////
// HTTP Strings //
//////////////////
const char destServer[] = "<host>";

const String connectionClose = " HTTP/1.1\n"
                           "Host: <host>\n"
                           "Connection: close\n\n";

////////////////////
// Pin Variables //
///////////////////

const int sensorPower = 7;
const int sensor1 = A0;
const int sensor2 = A1;
const int sensor3 = A2;
const int solenoid1 = 13;
const int solenoid2 = 12;
const int solenoid3 = 11;
const int signalLight = 10;


////////////////////
// Misc Variables //
///////////////////
int val1 = 0;
int val2 = 0;
int val3 = 0;

unsigned long last_watered;
unsigned long current_time;

const unsigned long day_in_milliseconds = 86400000;
const int sensor_samples = 5;

void setup()
{
  pinMode(signalLight, OUTPUT);
  digitalWrite(signalLight, LOW);
  Serial.begin(9600);

  pinMode(sensorPower, OUTPUT);
  digitalWrite(sensorPower, LOW);

  pinMode(solenoid1, OUTPUT);
  digitalWrite(solenoid1, LOW);
  pinMode(solenoid2, OUTPUT);
  digitalWrite(solenoid2, LOW);
  pinMode(solenoid3, OUTPUT);
  digitalWrite(solenoid3, LOW);

  // verifies communication with the WiFi shield, and sets it up.
  initializeESP8266();

  connectESP8266(); // connects to the defined WiFi network.

  // displayConnectInfo prints the Shield's local IP
  // and the network it's connected to.
  displayConnectInfo();

  last_watered = millis();
  waterAll();

}

int averageVal(int sensor) {
  int sum = 0;
  for (int i=0; i < sensor_samples; i++){
    sum += analogRead(sensor);
    delay(100);
  }
  return sum/sensor_samples;
}


void waterPlant(int solenoidPin) {
  Serial.println(F("Watering a plant"));
  digitalWrite(solenoidPin, HIGH);    //Switch Solenoid ON
  delay(5000);                      //Wait
  digitalWrite(solenoidPin, LOW);     //Switch Solenoid OFF
}


void waterAll() {
  waterPlant(solenoid1);
  delay(5000);
  waterPlant(solenoid2);
  delay(5000);
  waterPlant(solenoid3);
  waterUpdate();
}

void loop()
{
  digitalWrite(sensorPower, HIGH);
  delay(10);//wait 10 milliseconds
  val1 = averageVal(sensor1);
  val2 = averageVal(sensor2);
  val3 = averageVal(sensor3);
  digitalWrite(sensorPower, LOW);


  digitalWrite(signalLight, HIGH);
  sensorUpdate(val1, val2, val3);
  Serial.println(F("Request complete"));
  delay(10);
  digitalWrite(signalLight, LOW);

  if (millis() < last_watered || ( millis() - last_watered ) > day_in_milliseconds) {

    last_watered = millis();
    waterAll();
  }
  delay(1800000);
}

void initializeESP8266()
{
  int test = esp8266.begin();
  if (test != true)
  {
    Serial.println(F("Error talking to ESP8266."));

    errorLoop(test);
  }
  Serial.println(F("ESP8266 Shield Present"));
}

// connect Wifi Shield
void connectESP8266()
{
  int retVal = esp8266.getMode();
  if (retVal != ESP8266_MODE_STA)
  {
    retVal = esp8266.setMode(ESP8266_MODE_STA);
    if (retVal < 0)
    {
      Serial.println(F("Error setting mode."));
      errorLoop(retVal);
    }
  }
  Serial.println(F("Mode set to station"));
  retVal = esp8266.status();
  Serial.print(F("status is "));
  Serial.println(retVal);
  if (retVal <= 0)
  {
    Serial.print(F("Connecting to "));
    Serial.println(mySSID);
    retVal = esp8266.connect(mySSID, myPSK);
    if (retVal < 0)
    {
      Serial.println(F("Error connecting"));
      errorLoop(retVal);
    }
  }
}

void displayConnectInfo()
{
  char connectedSSID[24];
  memset(connectedSSID, 0, 24);
  int retVal = esp8266.getAP(connectedSSID);
  IPAddress myIP = esp8266.localIP();
  Serial.print(F("My IP: ")); Serial.println(myIP);
}

// Record moisture sensor values
void sensorUpdate(int box1, int box2, int box3) {
  String request;

  request += "GET /moisture?";
  request += "box1=";
  request += box1;
  request += "&box2=";
  request += box2;
  request += "&box3=";
  request += box3;
  request += connectionClose;
  makeRequest(request);
}

// Record plants watered
void waterUpdate() {
  String request;

  request = "GET /watered" + connectionClose;
  makeRequest(request);
}

// write request to ESP8266 client
void makeRequest(String request)
{
  ESP8266Client client;
  int retVal = client.connect(destServer, 80);

  Serial.print(F("connection is "));
  Serial.println(retVal);
  if (retVal <= 0)
  {
    Serial.println(F("Failed to connect to server."));
    return;
  }
  char buff[12];

  Serial.write(request.c_str());

  client.print(request);
  while (client.available())
    client.read(); // read() gets the FIFO char

  if (client.connected())
    client.stop(); // stop() closes a TCP connection.
}

// errorLoop prints an error code, then loops forever.
void errorLoop(int error)
{
  Serial.print(F("Error: ")); Serial.println(error);
  Serial.println(F("Looping forever."));
  for (;;)
    ;
}

The AccelLehenga

Mon, 30 Apr 2018 00:00:00 +0000

This is my friend Shalue. Shalue is super cool. Shalue deserves a super cool wedding. For Shalue’s wedding, I constructed the AccelLehenga.

The plan was simple. Chris and Shalue would provide me with a lehenga that she planned to wear to her reception and I would modify it. I learned a bunch from my previous wearable project and was confident I could produce something more polished.

One problem: this thing was embroidered, very embroidered. Every inch of the skirt was covered in heavy decoration. Sewable electronics are cool but they’re not particularly attractive. Previously, I had hidden everything under sheer fabric but that wasn’t going to work here; any LEDs I wanted to add had to be hidden somewhere on the surface without disrupting the existing decoration too much. Most existing sewable LED components were too big for this, so I ended up buying individual surface-mount LEDs and soldering loops onto them so I could sew them to the skirt.

I made about 50 of these.

These LEDs were serially addressable and could be connected using conductive thread and controlled with the FastLED library. I used conductive ribbon for the power and ground lines so that I could run longer strings of LEDs without losing brightness. For this project, I also used the Adafruit FLORA rather than the Lilypad Arduino as it has some more convenient connectors, namely a JST battery connector and a USB port. The whole thing ran on a Lipo battery pack that sat in a pocket in the skirt’s petticoat. We had the swap out the battery once during the party.

With the lights working, I was also able to add an accelerometer, the result was subtle but the lights would speed up the faster Shalue was moving.

Code

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_LSM9DS0.h>
#include <Adafruit_Sensor.h>

#include <FastLED.h>
#define NUM_LEDS 10
#define NUM_LEDS2 30
#define MOVE_THRESHOLD 500

CRGB leds[NUM_LEDS];
CRGB leds2[NUM_LEDS2];
Adafruit_LSM9DS0 lsm = Adafruit_LSM9DS0();
uint8_t start_brightness;
uint8_t brightness;
uint8_t cos_brightness;
double delta[10];
double storedVector;
int delta_i;
int light_speed;
int switch_state = 0;
int last_switch_state = 0;

void setup() {
  Serial.begin(9600);
  pinMode(0, INPUT);

  if (!lsm.begin())
  {
    Serial.println("Oops ... unable to initialize the LSM9DS0. Check your wiring!");
    while (1);
  }
  lsm.setupAccel(lsm.LSM9DS0_ACCELRANGE_2G);
  lsm.setupMag(lsm.LSM9DS0_MAGGAIN_2GAUSS);
  lsm.setupGyro(lsm.LSM9DS0_GYROSCALE_245DPS);
  FastLED.addLeds<NEOPIXEL, 6>(leds, NUM_LEDS);
  FastLED.addLeds<NEOPIXEL, 12>(leds2, NUM_LEDS2);

  delta_i = 0;
   for (int i = 0; i < 10; i++) {
    delta[i] = 0;
  }
  start_brightness = 0;

  lsm.read();
  storedVector = lsm.accelData.x*lsm.accelData.x;
  storedVector += lsm.accelData.y*lsm.accelData.y;
  storedVector += lsm.accelData.z*lsm.accelData.z;
  storedVector = sqrt(storedVector);
}

void loop() {
  // get new data!
  last_switch_state = switch_state;
  switch_state = digitalRead(0);
  Serial.println(switch_state);

  if (switch_state) {
    lsm.read();
    double newVector = lsm.accelData.x*lsm.accelData.x;
    newVector += lsm.accelData.y*lsm.accelData.y;
    newVector += lsm.accelData.z*lsm.accelData.z;
    newVector = sqrt(newVector);

    delta[delta_i] = abs(newVector - storedVector);
    //Serial.println(delta[delta_i]);
    delta_i = (delta_i + 1) % 10;

    double average_delta = 0;
    for (int i = 0; i < 10; i++) {
      average_delta += delta[i];
    }

    storedVector = newVector;

    brightness = start_brightness;
    for(int i = 0; i < NUM_LEDS; i++) {
      cos_brightness = cos8(brightness);
      leds[i] = CHSV(150,150, cos_brightness > 75 ? cos_brightness : 0);
      brightness = (brightness + 25) % 255;
    }
    brightness = start_brightness;
    for(int i = 0; i < NUM_LEDS2; i++) {
      cos_brightness = cos8(brightness);
      leds2[i] = CHSV(150,150, cos_brightness > 75 ? cos_brightness : 0);
      brightness = (brightness + 8) % 255;
    }
    FastLED.show();
    light_speed = (average_delta / 1000) * 1;
    start_brightness = (start_brightness + (light_speed > 5 ? light_speed : 5)) % 255;

  } else {
     for(int i = 0; i < NUM_LEDS; i++) {
      leds[i] = CHSV(0,0,0);
    }
    for(int i = 0; i < NUM_LEDS2; i++) {
      leds2[i] = CHSV(0,0,0);
    }
    FastLED.show();
  }

  delay(30);
}

Back to hiding the LEDs. We had very carefully removed a bunch of gems from the skirt in order to make space for the lights. I was able to print a hollowed out version of these gems using clear filament and sew them over the LEDs. You could still see the chips through the gems, but the illusion was mostly seamless it you weren’t looking too closely.

Shalue was happy, which makes me happy. There were some glitches the day of the reception, which like all Arduino problems were mostly solved by pressing the reset button. I may or may not have followed 15 feet behind her for the whole night just to make sure the thing was still working.

Bonus: A Vagabond Jacket

Shortly after finishing the AccelLehenga, I used a similar process to make a much simpler piece for myself. This one borrows Shisha embroidery techniques to disguise the LEDs.

Killing Me Softly with Keyboard Input

Sun, 22 Jan 2017 16:00:00 +0000

I am, for the most part, not here to get into unwinnable debates. Some decisions are kind of arbitrary. Sometimes you go along with convention because that’s what is familiar. Sometimes you just have to forge your own path. So I am not going to spend time justfying why I put the tab bar on the bottom of an Android app instead of the top. Suffice to say, I wanted to do it and I did it and so can you.

I’m not alone in this decision. I know this because there’s a Material Design spec for this exact thing. It’s mostly what you would expect: block colours, not too cluttered, etc. But then there’s one comment towards the end…

“Bottom sheets, navigation drawers, and keyboards appear in front of the bottom navigation bar, temporarily covering it.”

Seems reasonable, just hide that view when the keyboard is visible.

Wait….

You can’t. You have no information about what the keyboard is doing. How is that supposed to work?

The Android Manifest

So the official way to customize any keyboard-related behaviour is by setting windowSoftInputMode in the Android Manifest. There are ~~two~~ three options here:

adjustResize: This is not what you want. At least, not here. This squashes all the squashable elements in the window so that everything still fits, which is normally exactly what you want, but it does nothing to hide the tab bar.

adjustPan: This keeps everything the same size and pans the layout so that the focused element is somewhere above the keyboard. This will probably hide the tab bar; it will probably hide other parts of your layout as well. You may not want to have those parts of your layout hidden depending on what they are, in which case this is not optimal.

adjustNothing: This is not a documented option but I promise it exists and it does exactly what you think it does. The window does not change at all here and the keyboard appears on top of it. This will definitely hide the tab bar and will probably hide whatever is directly above the tab bar; even if that thing is the text field you are currently editing. Depending on your layout, this might be the same, better, or worse than adjustPan.

Hopefully either adjustPan or adjustNothing is sufficient for you and if one of them is, I highly suggest you use it and get on with your life, because your other options are not pretty. But what if you want to hide the tab bar AND resize the rest of the layout?

The Magic Number Method

Searching for a better solution, I did manage to find this StackOverflow answer. This method simply assumes that if the main view is shortened by a totally arbitrary number of pixels, the keyboard must be present. It works fine in spite of the magic number except…

Do you see it? DO YOU SEE IT?!?!

I had been calling setVisibility(GONE) to hide the tab bar and the update is just a liiittle bit too slow; the tab bar is visible as the keyboard is withdrawing. Obviously, this will not stand.

The RelativeLayout Method

My eventual solution relies on the equivalent of a CSS hack. The layout for the main activity looks some like this:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/activity_main"
    android:fitsSystemWindows="true"
    android:layout_width="match_parent" android:layout_height="match_parent">

    <android.support.design.widget.TabLayout
        android:id="@+id/tabs"
        android:layout_width="match_parent"
        android:layout_height="60dp"
        android:layout_alignParentBottom="true"
        android:background="@color/colorPrimary"
        app:tabTextColor="@android:color/white"
        app:tabSelectedTextColor="@android:color/white"/>

    <android.support.v4.view.ViewPager
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/pager"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_alignParentTop="true"/>

</RelativeLayout>

Both the main ViewPager and the tab bar are kept inside a RelativeLayout, aligned with the top and bottom of the parent respectively but added in the opposite order. This matters because the order of the Views in a RelativeLayout is the order in which they are drawn. Given that, we simply need to listen for layout changes and adjust the height of the ViewPager accordingly, so that is takes up either “all the available space” or “all the available space minus the height of the tab bar” depending on what’s available.

public class MainActivity extends AppCompatActivity {

  ViewPager viewPager;
  TabLayout tabLayout;
  ViewPagerAdapter viewPagerAdapter;

  private View rootView;
  private int maxViewSize;
  private int previousHeight;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.alt_activity_main);

    viewPager = (ViewPager) findViewById(R.id.pager);
    tabLayout = (TabLayout) findViewById(R.id.tabs);
    viewPagerAdapter = new ViewPagerAdapter(getSupportFragmentManager());
    viewPager.setAdapter(viewPagerAdapter);
    tabLayout.setupWithViewPager(viewPager);

    rootView = findViewById(R.id.activity_main);
    // assumes no keyboard activity at start
    maxViewSize = rootView.getHeight();
    previousHeight = 0;

    rootView.addOnLayoutChangeListener(new View.OnLayoutChangeListener() {
      @Override
      public void onLayoutChange(View view, int l, int t, int r, int b,
                                 int ol, int ot, int or, int ob) {
        Rect rect = new Rect();
        view.getWindowVisibleDisplayFrame(rect);

        TypedValue tv = new TypedValue();
        MainActivity.this.getTheme().resolveAttribute(
                android.R.attr.actionBarSize, tv, true);
        int actionBarHeight = getResources().getDimensionPixelSize(
                tv.resourceId);
        int currentHeight = rect.bottom - rect.top - actionBarHeight;

        if (currentHeight == previousHeight) {
          return; // prevent recursion when modifying LayoutParams
        }
        if (currentHeight > maxViewSize) {
          // recover if we didn't get the right window size the first time
          // (eg. keyboard up, view.getHeight() = 0 on first pass, etc.)
          maxViewSize = currentHeight;
        }

        int maxPagerHeight = maxViewSize - tabLayout.getHeight();

        ViewGroup.LayoutParams layoutParams = viewPager.getLayoutParams();
        if (currentHeight < maxPagerHeight){
          layoutParams.height = currentHeight;
        }
        else {
          layoutParams.height = currentHeight - tabLayout.getHeight();
        }
        viewPager.setLayoutParams(layoutParams);
        previousHeight = currentHeight;
      }
    });
  }

  ...more code here...
}

The tab bar will hide itself under the ViewPager if it does not have enough space, avoiding the visual hiccup of removing it and waiting for the ViewPager to readjust.

A couple notes:

Setting layoutParams inside onLayoutChange actually forces Android to run a second layout pass, which created some warning logging but otherwise works as long as you only call setLayoutParams when the layout actually changes.
The actionBarHeight variable can be omitted if there is no ActionBar.
windowSoftInputMode for this activity MUST be set to adjustResize|stateHidden so that the keyboard is down when the activity is created.

I’ve tested this method on a handful of different devices and it seems to work. Not all Android devices were consistent about how they measure the screen but getWindowVisibleDisplayFrame worked everywhere. That said, there are enough things that can go wrong here that you should probably use adjustNothing if at all possible.

The Rise of Plant-thulu

Thu, 22 Sep 2016 22:00:00 +0000

InMoov finger tutorial + knit tentacle pattern

The Dramatic Entrance Machine

Mon, 19 Sep 2016 23:30:00 +0000

Some friends and I attended a certain gathering in the desert recently and one of the things we brought with us was a pair of saloon doors. Y’know, typical desert camping gear. A few weeks before we left, someone mentioned that the doors used to have a motion-activated speaker that was meant to play a random sound whenever someone entered, but it was removed because it gave too many false positives. I thought, “A reed switch might be better suited for that,” then I started looking at reed switches, then I started looking at how to play sound files from an Arduino, and now here we are.

The reed switch itself was dead simple. It consists of two magnets to be installed on either side of the door. The switch is off when the magnets are within half an inch or so of each other and on when they move farther apart. It connects to a pin on the Arduino. Dead. Simple.

The audio was also simple. I bought an MP3 player shield from Sparkfun, being fairly confident that it would do everything I needed and then some. Namely, it takes an SD card full of audio files, it accepts a standard audio jack, and it has a simple library associated with it. The jack was especially important to me because I definitely did not have time to mess around with DIY speakers again.

Weird caveat with the audio jack, though: because the shield is designed to work with headphones out of the box, the reference voltage on the audio jack is not actually ground. Sparkfun has a guide that explains this in greater detail, but the gist is:

It works fine for headphones
It works fine for external speakers as long as they’re self-powered
Messing around with DIY speakers now involves slightly more messing around
Never, ever, ever, ever let the “not-ground” on the headphone jack connect back to the actual ground on the Arduino. This will break everything. Badly.

This was fine for my purposes, since I wanted to just hook up external speakers anyway. The only requirement was that the speakers should have a separate power source. I even got to use the pathetic speakers that I made last year since they were a) battery-powered, b) small and c) I don’t care what happens to them.

Then, there was the issue of power. The nature of desert camping meant that I wouldn’t have a reliable power source to plug into so I simply resorted to “bring lots of batteries.” I put a 9-volt battery behind a high-efficiency regulator (the one I bought for my LED dress) and called it a day. In an attempt to conserve power, I also added a relay between the battery terminals on the speakers, so that I could turn the speakers off when I didn’t need then while still keeping them on a separate circuit.

The full code is below. The reed switch is on pin 5 and the relay is on pin 10. On each loop we check if the door has just opened and, if so, select a random file and play it.

#include <SPI.h>
#include <SdFat.h>
#include <SdFatUtil.h>
#include <SFEMP3Shield.h>

SdFat sd;
SFEMP3Shield MP3player;
uint16_t fileCount;
int previousDoor;
int door;

void setup() {

  randomSeed(analogRead(0));
  pinMode(5, INPUT_PULLUP);
  pinMode(10, OUTPUT);

  digitalWrite(10, LOW);

  //start the shield
  sd.begin(SD_SEL, SPI_FULL_SPEED);

  //count files
  SdFile file;
  char filename[13];
  sd.chdir("/",true);
  fileCount = 1;
  while (file.openNext(sd.vwd(),O_READ))
  {
    file.getFilename(filename);
    if ( isFnMusic(filename) ) {
      fileCount++;
    }
    file.close();
  }


  MP3player.begin();
  MP3player.setVolume(0,0); //loudest

  previousDoor = 0;
  door = 0;
}

void loop() {

  door = digitalRead(5);

  if (door == HIGH and previousDoor == LOW and !MP3player.isPlaying()){
    long randomSong = random(1, fileCount);
    digitalWrite(10, HIGH);
    delay(20);
    MP3player.playTrack(randomSong);
    while (MP3player.isPlaying()) {
      delay(100);
    }
    digitalWrite(10, LOW);
  }

  previousDoor = door;
  delay(200);

}

To protect them from the elements, most of the components were stored in plastic pencil cases, which were screwed directly to the door frame.

And it works!

Well, mostly. Predictably, the speakers were a little too quiet and had to be swapped out with another set that we had on hand. The battery also didn’t last long and had to be changed frequently. (I never bothered to time it. It was more than a few hours but definitely not a full day.) Most importantly, the saloon doors are supposed to have hinges that swing shut after they’ve been opened, but between the wind, the dust and the posts not being quite straight, the doors never really closed by themselves. Still, during times when we had lots of people visiting, we would send someone to stand by the door and usher people through it, manually closing the door behind them. It became a fun way to entertain the guests.

A Dress That Wants to Dance

Sun, 13 Mar 2016 22:00:00 +0000

I found some conductive fabric in a drawer one day and started thinking about using it in a sewing project. The (eventual) result was a dress with hidden capacitive sensors and Arduino-controlled LEDs.

I started with a simple dress pattern and modified it to use two layers: black lace over a grey lining, trying to match the colour of the conductive fabric as closely as possible. I used a hand applique stitch to sew squares of conductive fabric onto the lining bodice at the waist and shoulders, so that it would be obscured under the lace layer when the bodice was complete. These will become the basis for the capacitive sensors.

Once the dress was finished, I could start working on the circuit. The whole thing is controlled by a Lilypad Arduino and the conductive fabric patches are connected to their respective pins (or each other) with conductive thread. Each capacitive sensor also needs a resistor, which controls the sensitivity of the sensor, and these hard components are connected to the soft circuit using metal fabric snaps. Finally, two strings of addressable RGB LEDs (WS2811) were labouriously sewn into the skirt

The code is fairly simple. I’m making use of two very useful libraries: FastLED and CapactiveSensor. CapacitiveSensor takes two connected pins, toggles the output of one pin and records the time it takes to receive the same signal from the other pin; a longer wait indicates higher capacitance across the two pins. In this sketch, if any of the sensors are above a threshold, we animate a random set of LEDs. The threshold is set so that the sensors should only respond to direct contact and not to the person currently wearing the dress. (This can be finicky)

	#include <FastLED.h>
	#include <CapacitiveSensor.h>
	#define NUM_LEDS 100
	#define RANDOM_LEDS 20
	#define THRESHOLD 1000

	CRGB leds[NUM_LEDS];
	CapacitiveSensor waist_left = CapacitiveSensor(13,12);
	CapacitiveSensor shoulder_left = CapacitiveSensor(11,10);
	CapacitiveSensor shoulder_right = CapacitiveSensor(9,8);
	CapacitiveSensor waist_right = CapacitiveSensor(6,7);

	void setup() {
	  FastLED.addLeds<NEOPIXEL, 3>(leds, NUM_LEDS);
	}

	void loop(){
	  static uint8_t fadeIn[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
	  static uint8_t fadeOut[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
	  static long loop_counter = 0;
	  static uint8_t saturation = 250;
	  static uint8_t hue = 175;
	  static uint8_t max_value = 128;
	  long cap1 = 0;
	  long cap2 = 0;
	  long cap3 = 0;
	  long cap4 = 0;

	  for (int i=0; i<RANDOM_LEDS; i++){
	    fadeIn[i] = random(0, NUM_LEDS);
	  }
	  uint8_t angle = 0;
	  while (angle <= max_value){
	    cap1 =  waist_left.capacitiveSensor(30);
	    cap2 =  shoulder_left.capacitiveSensor(30);
	    cap3 =  shoulder_right.capacitiveSensor(30);
	    cap4 =  waist_right.capacitiveSensor(30);
	    loop_counter++;

	    if (cap1 > THRESHOLD  || cap2 > THRESHOLD || cap3 > THRESHOLD || cap4 > THRESHOLD){
	      angle = angle + 8;
	      for (int i=0; i<RANDOM_LEDS; i++){
	        leds[fadeIn[i]].setHSV(hue,saturation,cos8(128-angle));
	        leds[fadeOut[i]].setHSV(hue,saturation,cos8(angle+(128-max_value)));
	      }
	    } else {
	      angle = 0;
	      for (int i=0; i<RANDOM_LEDS; i++){
	        leds[fadeIn[i]].setHSV(hue,saturation,0);
	        leds[fadeOut[i]].setHSV(hue,saturation,0);
	      }
	    }
	    FastLED.show();
	    delay(10);
	  }
	  for (int i=0; i<RANDOM_LEDS; i++){
	    fadeOut[i] = fadeIn[i];
	  }
	  if (loop_counter >= 2500) {
	     loop_counter = 0;
	     waist_left.reset_CS_AutoCal();
	     shoulder_left.reset_CS_AutoCal();
	     shoulder_right.reset_CS_AutoCal();
	     waist_right.reset_CS_AutoCal();  
	  }
	}

The power supply lives in a pouch on the wearer’s leg. This particular piece was made in a rush (I was trying to finish in time for an event) and uses a battery behind a basic 5V regulator. A card tin holds the components and serves as a much-needed heat sink. At some point I plan to replace the existing regulator with a high-efficiency version.

The finished product is a dress made for dancing. Now if only I knew how to dance.

I made Speakers!

Sat, 10 Oct 2015 18:00:00 +0000

So I just finished making a small set of Fab Speakers. I’m excited about this not because it’s a particularly complicated project, nor because these are particularly high-quality speakers, but it represents the first time I’ve used soldering and/or 3D printing for something useful. The sound quality is decidedly OK. If you’re the sort of person who regularly puts your phone in a glass to make it louder, you may find that these speakers fill a gaping hole in your otherwise happy and fulfilling life; otherwise, they are nothing to write home about.

The design for the speakers, including how to get the materials and detailed instructions for assembling them, are all available here. The instructions are easy to follow and I won’t reiterate them here. Instead, I will talk about the various ways in which I deviated from the instructions, and the various degrees of strife that it caused me.

First of all, I lost some of the surface mount resistors because everything is tiny and had to replace them with regular resistors, which is fine but slightly ugly. I also screwed up one of the chips on my first try, also because everything is tiny. Other than that, the board was easier than I expected.

Once I had finished the circuit, turning on the speakers for the first time was … a decidedly disappointing experience. Turns out the enclosure matters a lot, a fact which I hadn’t thought about at first but makes sense once you start to reason about how sound waves work. After all, the speaker drivers themselves are more or less just vibrating sheets of plastic, and vibrating plastic is useful only insofar as it can create vibrating columns of air. The enclosure suspends and secures the driver by the rim and creates air pressure behind it, both of which influence the driver’s ability to push the air directly in front of it. Beyond that sort of basic intuition, real speaker design is incredibly complicated and anything that can be made in an afternoon on a kitchen table is certainly not optimal. Ultimately, the sound from the “naked” speakers served to lower my expectations appropriately. Every time I turned them on while I was assembling the enclosure, I was pleasantly surprised to find that the sound was more and more like actual music.

My biggest deviation from the original was that I printed the structural pieces for the enclosure, owing to having easier access to a 3D printer than I do to a laser cutter. I started by using the schematic and extruding each of the pieces by 6mm to create the shape files. This worked pretty much perfectly except that everything ended up being a fraction of a millimeter larger than expected once printed and none of the snap fit pieces actually fit together. Ooops. Rather than print everything all over again, I ended up inexpertly sanding things down and using Sugru to prevent the pieces from wiggling. I’ve included the shape files for anyone who wants to try something similar, but I would recommend adding a little clearance to each of the pegs to save yourself some misery.

Overall I think they turned out OK.

Shape files: 1 2 3 4 5 6 7 8 9 10