Sand Mirror - Final Project Planning

I did some more work planning out my ideas for the sand mirror. At this point, I am only going to build a 1 x 6 vertical grid of fans and have a simple interaction to trigger a series of fan events, whether that be timed delays between each fan starting up or a system of valves opening to allow air to pass down a tube. Hopefully play testing will reveal how well simply a lone fan behind the sand wall might work, in which case, I could put a joystick in front of it for folks to interact with.

Below you will see the system diagram. I plan on using a ULN2003 to control the 30 mm fans.


Bill of Materials

For the bill of materials, the fans are going to be the most costly by far, relative to any of the other materials. For this reason, I am hoping play-testing may reveal that using one powerful fan that say, rotates in the X and Y axis behind the sand, might be an alternative to the 6 fans.

Below is the short-term timeline and work list:

Fri Nov 16th - Laser Cutting cardboard frame

Sat Nov 17th - Acquire 6 fans from local hobby shop

  Fan Testing, PVC fitting

Mon Nov 19th - Build 1x6 fan and test

Mon Nov 26th - Further testing and interaction design

Thur Nov 29th - Final Tweaks and touches


Here is my current to do list and my thoughts and unsolved mysteries thus far.

To Do:

  • more testing

  • build box for sand

  • measure fan width and match PVC to fit

  • make PVC pieces

  • laser Cut cardboard

  • 3D print valves to control air flow

Challenges at the moment:

  • finding, sourcing, and testing a strong enough fan at a small enough size - duct fans for hobby RC jet planes may be the ticket…

  • focusing the air into small areas - PVC pipe w straws inside

  • the larger each fan’s size, the larger the grid will be which means using more sand

  • accelerating and decelerating the fan quickly to get the desired responsiveness - 3D print valves?

  • getting a smooth rate of falling sand

  • getting a consistent pattern of falling sand - perhaps different grades of sand would be better

I should add that I bought a 50lb bag of from Home Depot cause that was the smallest amount on offer. I did some initial testing and found that a computer fan was much too small, unless there was very little sand being used. I found a larger size 6” personal fan that seemed to work better, although the wind pattern was not very accurate. I held a smaller bucket of sand over this fan and saw that the fan was effective. However, the sand had quite a bit of dust coming off of it.

I described the situation to my roommate and he recommended that I wash the sand. Foolishly, I acted like I knew how to go about that and devised my own way which involved a large piece of fabric, about the size of a shower curtain, that I got from the Soft Lab scraps and the utility sink in the shop. It took about two hours to do all 50lbs which was probably overkill, but I was already at it so why not?

Then I had to DRY the sand… First I tried to leave it in that small red bucket overnight by the radiator, which I thought was so smart. But when I came back in the morning, not hardly a dent had been made and the sand was still damp. So I brought my car to school to get the sand and take it home to dry. This took a few days of spreading it out over a heating blanket covered with clear plastic. Perhaps my roommate would have had a better solution, but I have what I need now so…

drying sand 1.JPG

Sand Mirror - Final Project Sketch

I would like to make a low resolution mirror using sand and air. There will be a container of sand above an X/Y grid of holes. From a long slot opening downward from the bottom of the container, the sand will fall in front of the holes which push and pull small currents of air in and out.

By moving the sand in the Z space as it falls downward, the mirror will give the impression of a 3-D image moving. One particular feature is that sand will constantly be flowing downward, giving the illusion of an image that is “alive”. This could also be done with some piece of thin fabric as in this video.

Another option I found besides programmable air is using fans like these. This way, I would not have to worry about the programmable air and its noisy system and I could make a network of fans. Computer fans also come to mind. They are usually slow, cheap, and I can flip the phase of the power to have them flow in the opposite direction. So that is a better sounding option to me. Below is a drawing of what I have so far.

sand-mirror.JPG

Betty The Librarian (Phase 1)

So we’re gonna make ol’ Betty come to life. She’s a librarian now and a pretty cranky one too. Used to work as a crossing guard in my neighborhood, but the sun became too much for her as she got up in age, and the standing all day. But boy did she wave a mean finger in her time, served with an extra of grimace - ooh wee!

She tried to find other work which would let her keep her whistle, of which everyone knew she was so fond, but, alas - she wasn’t in shape enough to be a referee; much too old to be a poilce officer; never played sports a day in her life (so coaching was out) - a lifeguard perhaps?? Lord knows ol’ Betty would sink like a rock before saving anyone else, let alone herself!

So when Betty got the gig at the local library, she retired her beloved whistle and traded it in for a hearty “Shhhh!!!”. It was a good fit in retrospect, but at the time she recalls feeling like one of those old, disgraced sheriffs in the Old West, turning in their badge as they got relieved of duty. “At least she didn’t end up with a hole in the head!” she thought.

But despite the peaceful hours floating by in the library, out of the hot sun and in the AC provided by the taxpayers of area code 11238, Betty developed a blistering case of Type 2 Diabetes, most unfortunately causing her to have to have both her legs and arms amputated. Sad to say, I know, but damned if she didn’t love her Kit Kats and Tab and wasn’t going to let any “medical” doctor tell her what to do. Stubborn old bird she was, stubborn as hell.

So off the appendages came and pretty soon there was nothing left but her head, given that the cancer had eaten her to the bone… Oh! Did I forget to mention that she smoked a lot too? I did, I did! My word did she smoke!! Loved those cigarettes, but unlike most smokers', who had a preferred brand that they stuck to for their whole and often much-shortened lives, Betty would smoke damn-near anything she could find. And she was so cheap you know, she had a habit of taking butts straight out of the ash trays you’d find in most public places, of which the library was one of course. So she was like a pig in u-kno-what. Hell, most times people would wait around for minutes at a time wondering where Betty had gone off too until the smoke cleared and you could just make her figure out again. Never coughed once in her life though, peculiar as that sounds. You can try to add that up yourself I guess!

Goodness me retirement sure was tough for Betty it seems. But now, luckily, with technology pioneered by the great Ray Kurzweil, Betty has been able to port her brain, via a special USB Z adapter (MSRP $2,399), onto a tiny microprocessing chip - hey folks said she was a lot of things but bright was not one of them - with just enough functionality to minimally perform her duties as an assistant librarian. Don’t you worry one bit though about the Dewey Decimal system giving her any trouble. No fancy text recognition software or motorized appendages (as of yet at least). No, the entire contents of the local library where Betty works now consists of half a half-dozen PC’s and a couple of Reagan-era VHS tapes.

Design-wise, Betty will be outfitted with a microphone for ears, an LED strip in the shape of a frown face to be her mouth, an mp3 shield to play a number of different “SHHHshhhh!!” sounds out of a small speaker, which is apropos, given that the throat cancer clear ate up most all of her vocal cords, while still retaining some musicality to her repertoire given the multiple samples. And although she no longer has any eyes, she will have LED placeholders so the children don’t stare too long and bump into a wall or something.

One day it would be nice for her to have a wheel chair with which she could follow you around the library with, especially in the case of trouble makers, but we may still have much to dream!

Here’s to Betty’s surgery - hoping it goes well!

Jim Swiggins

Betty The Librarian Sketch

Pot controlling Neo Pixels LEDs.

I first started out looking online for documentation for the geeetech mp3 shield that I had. These companies are nuts though as they sell mutliple versions of the same board, mutlple names of the same board, different features with not indication and often different pinouts. After much searching of the Arduino forum, I was able to find some links to documentation, although i wasn’t able to load the libraries that came with the docs. This may be something where I get some outside help. I figured I would make some kind of progress and go on to the LED strip…

I wasn’t able to get the LED’s to respond to the piezo input or to me sining through a speaker, the reasons for which weren’t clear to me. So I just used a pot for now to get the LED program right. Then it’s just a matter of reading the mic input (which may require a mic pre now that I think of it?)

I wasn’t quite happy in the end with my programming for the LEDs. There is an insane string of IF statements that should be turned into a FOR loop somehow, but my brain was too fried from looking for mp3 shield libraries to work it out.

You can see from the code that I mapped the values coming in from the analogRead on the pot into a variable I could evaluate in IF statements as I segmented each LED. Check it out below:

#include <Adafruit_NeoPixel.h> // including the Adafruit library
#define PIN 12 // defining the PWM pin
#define N_LEDS 10 // number of LED units on the strip

Adafruit_NeoPixel strip = Adafruit_NeoPixel(N_LEDS, PIN); //decalred NeoPixel object


int fade = 0;
boolean turn = false;
int level;
int levelMap;
int nLEDs = 10;

void setup() {
  strip.begin();
  Serial.begin(9600);

}

void loop() {

  level = analogRead(A0);
  levelMap = map(level, 50, 1000, 0, 12);
  if (levelMap > 1) {
    strip.setPixelColor(0, 0, 10, 0);
    strip.setPixelColor(1, 0, 0, 0);
    strip.setPixelColor(2, 0, 0, 0);
    strip.setPixelColor(3, 0, 0, 0);
    strip.setPixelColor(4, 0, 0, 0);
    strip.setPixelColor(5, 0, 0, 0);
    strip.setPixelColor(6, 0, 0, 0);
    strip.setPixelColor(7, 0, 0, 0);
    strip.setPixelColor(8, 0, 0, 0);
    strip.setPixelColor(9, 0, 0, 0);
    if (levelMap > 2) {
      strip.setPixelColor(0, 0, 10, 0);
      strip.setPixelColor(1, 0, 10, 0);
      strip.setPixelColor(2, 0, 0, 0);
      strip.setPixelColor(3, 0, 0, 0);
      strip.setPixelColor(4, 0, 0, 0);
      strip.setPixelColor(5, 0, 0, 0);
      strip.setPixelColor(6, 0, 0, 0);
      strip.setPixelColor(7, 0, 0, 0);
      strip.setPixelColor(8, 0, 0, 0);
      strip.setPixelColor(9, 0, 0, 0);
      if (levelMap > 3) {
        strip.setPixelColor(0, 0, 10, 0);
        strip.setPixelColor(1, 0, 10, 0);
        strip.setPixelColor(2, 0, 10, 0);
        strip.setPixelColor(3, 0, 0, 0);
        strip.setPixelColor(4, 0, 0, 0);
        strip.setPixelColor(5, 0, 0, 0);
        strip.setPixelColor(6, 0, 0, 0);
        strip.setPixelColor(7, 0, 0, 0);
        strip.setPixelColor(8, 0, 0, 0);
        strip.setPixelColor(9, 0, 0, 0);
        if (levelMap > 4) {
          strip.setPixelColor(0, 0, 10, 0);
          strip.setPixelColor(1, 0, 10, 0);
          strip.setPixelColor(2, 0, 10, 0);
          strip.setPixelColor(3, 0, 10, 0);
          strip.setPixelColor(4, 0, 0, 0);
          strip.setPixelColor(5, 0, 0, 0);
          strip.setPixelColor(6, 0, 0, 0);
          strip.setPixelColor(7, 0, 0, 0);
          strip.setPixelColor(8, 0, 0, 0);
          strip.setPixelColor(9, 0, 0, 0);
          if (levelMap > 5) {
            strip.setPixelColor(0, 0, 10, 0);
            strip.setPixelColor(1, 0, 10, 0);
            strip.setPixelColor(2, 0, 10, 0);
            strip.setPixelColor(3, 0, 10, 0);
            strip.setPixelColor(4, 0, 10, 0);
            strip.setPixelColor(5, 0, 0, 0);
            strip.setPixelColor(6, 0, 0, 0);
            strip.setPixelColor(7, 0, 0, 0);
            strip.setPixelColor(8, 0, 0, 0);
            strip.setPixelColor(9, 0, 0, 0);
            if (levelMap > 6) {
              strip.setPixelColor(0, 0, 10, 0);
              strip.setPixelColor(1, 0, 10, 0);
              strip.setPixelColor(2, 0, 10, 0);
              strip.setPixelColor(3, 0, 10, 0);
              strip.setPixelColor(4, 0, 10, 0);
              strip.setPixelColor(5, 20, 10, 0);
              strip.setPixelColor(6, 0, 0, 0);
              strip.setPixelColor(7, 0, 0, 0);
              strip.setPixelColor(8, 0, 0, 0);
              strip.setPixelColor(9, 0, 0, 0);
              if (levelMap > 7) {
                strip.setPixelColor(0, 0, 10, 0);
                strip.setPixelColor(1, 0, 10, 0);
                strip.setPixelColor(2, 0, 10, 0);
                strip.setPixelColor(3, 0, 10, 0);
                strip.setPixelColor(4, 0, 10, 0);
                strip.setPixelColor(5, 20, 10, 0);
                strip.setPixelColor(6, 20, 10, 0);
                strip.setPixelColor(7, 0, 0, 0);
                strip.setPixelColor(8, 0, 0, 0);
                strip.setPixelColor(9, 0, 0, 0);
                if (levelMap > 8) {
                  strip.setPixelColor(0, 0, 10, 0);
                  strip.setPixelColor(1, 0, 10, 0);
                  strip.setPixelColor(2, 0, 10, 0);
                  strip.setPixelColor(3, 0, 10, 0);
                  strip.setPixelColor(4, 0, 10, 0);
                  strip.setPixelColor(5, 20, 10, 0);
                  strip.setPixelColor(6, 20, 10, 0);
                  strip.setPixelColor(7, 40, 10, 0);
                  strip.setPixelColor(8, 0, 0, 0);
                  strip.setPixelColor(9, 0, 0, 0);
                  if (levelMap > 9) {
                    strip.setPixelColor(0, 0, 10, 0);
                    strip.setPixelColor(1, 0, 10, 0);
                    strip.setPixelColor(2, 0, 10, 0);
                    strip.setPixelColor(3, 0, 10, 0);
                    strip.setPixelColor(4, 0, 10, 0);
                    strip.setPixelColor(5, 20, 10, 0);
                    strip.setPixelColor(6, 20, 10, 0);
                    strip.setPixelColor(7, 40, 10, 0);
                    strip.setPixelColor(8, 40, 10, 0);
                    strip.setPixelColor(9, 40, 0, 0);
                  } else if (levelMap <= 1) {
                    for (int i = 0; i < 10 ; i++) {
                      strip.setPixelColor(i, 0, 0, 0);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }


strip.show();
Serial.print("level ");
Serial.print(level);

Serial.print(":  levelMap ");
Serial.println(levelMap);


}

Making A Melody

I further investigated making melodies on the Arduino and found this tutorial: https://www.arduino.cc/en/Tutorial/toneMelody

This was helpful because it gives a library of note names for each frequency value in tone and also shows a way to make divisions of the beat per each value in the array. And also, you just make the file yourself and reference it using pitch.h instead of a library. This was a helpful feature to learn. I modified the code to play the first few notes of Claire De Lune. The code for the patch is below and the link to the pitch.h file is in the tutorial above.

/*
  Melody

  Plays a melody

  circuit:
  - 8 ohm speaker on digital pin 8

  created 21 Jan 2010
  modified 30 Aug 2011
  by Tom Igoe

  This example code is in the public domain.

  http://www.arduino.cc/en/Tutorial/Tone
*/

//you must make the pitches.h file yourself 
//which references the frequency values by note names
#include "pitches.h"


// notes in the melody:
int melody[] = {
  NOTE_C4, NOTE_C5, NOTE_A4, NOTE_G4, NOTE_A4, NOTE_G4
};

// note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {
  4, 4, 1, 8, 8, 1,
};

void setup() {
  // iterate over the notes of the melody:
  for (int thisNote = 0; thisNote < 6; thisNote++) {

    // to calculate the note duration, take one second divided by the note type.
    //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
    int noteDuration = 1250 / noteDurations[thisNote];
    tone(8, melody[thisNote], noteDuration);

    // to distinguish the notes, set a minimum time between them.
    // the note's duration + 30% seems to work well:
    int pauseBetweenNotes = noteDuration * 1.1;
    delay(pauseBetweenNotes);
    // stop the tone playing:
    noTone(8);
  }
}

void loop() {
  // no need to repeat the melody.
}

Controlling A Sequence With A Force Sensor

For this project, I borrowed a force sense from a class mate and sought to use it to control pitch. Once I had the sensor’s values mapped to a variable within the audible range, I decided to test out my circuit by making a sequence of notes played out of a speaker.

For this, I used the tone function with the variable as my frequency and then multiplied that fundamental frequency by multiples of 1.06 to get other note values, as I new that one half step on a keyboard is 6% higher in frequency than the previous note. So (1.06*2) is a second, (1.06*3) is a third, and so on. To get a sequence of notes, one played after the other, I used the delay function in even intervals. So then when I pressed the force sensor, I was able to move the overall pitch of the sequence up together as it cycled through. Here is videos of each step and the final code is for the sequence.

//how to make a force sensor control the pitch of a sequence
// patch the force sensor to A0 and ground, and the speaker D12

void setup() {
  // put your setup code here, to run once:
  pinMode(12, OUTPUT);
Serial.begin(9600);
}

void loop() {
  // read the analog input;
  int sensorReading = analogRead(A0);
// convert from ADC reading to voltage
  float voltage = sensorReading * (5.0 / 1024.0);

   tone(12, voltage*100);
   delay(10);
   tone(12, voltage*100*(2*1.06));
   delay(10);
   tone(12, voltage*100*(3*1.06));
   delay(50);
   tone(12, voltage*100*(4*1.06));
   delay(100);
   tone(12, voltage*100*(2*1.06));

  Serial.print(voltage);
  Serial.print("\t");
  Serial.println(sensorReading);

}

Thoughts on Interaction Design

This week, I took a look around a few places on my regular routes, keeping an eye out for interactivity, and ran into Willie and Thomas, two of my favorite arm-chair philosophers, on the nature of interactivity and ease (or difficulty) of use. Here’s my rough transcription of their conversation:

Willie: So when thinking how easy an object is to use, I think of how high the bar for understanding its basic function is and how easy it is to make the object to function as intended.

 The interactive installation in the ITP lobby.

The interactive installation in the ITP lobby.

Thomas: Yea! So the installation in the ITP lobby as one example (I took a video of it here). For this piece, there really is no interactive role except that you just walk up to it. It functions like a mirror which is a familiar object and sight is a primal and basic sense. So the user understands the piece right away. However, the effect is exaggerated when reproduced from a camera, which provides a lower resolution framework for viewing the effect (see the video).

Willie: Yea, so cool in the way that the piece itself is a lower resolution reproduction of reality and you get a better view of it by lowering the resolution! Haha!

[lots of laughter, people on the subway looking over]

Thomas: So some things we just know how to work.

Willie: Like a door knob...

Thomas: Yea! Just reach out and turn. Although perhaps this isn’t the best example, since I’ve not walked into businesses, thinking the door was locked, when I just needed to push instead of pull..

Willie: Ok, so maybe something more primal, like a hammer or a knife…

Thomas: I see what you’re thinking here.. Hammers definitely make a lot of sense when you pick it up, basic function, lots of payoff and utility - although watch out! Cause if you screw it up, there could be some sore thumbs to pay!

Willie: True true! [winces] .. Ok what about a cup!

Thomas: A cup?

Willie: Like a cup or glass of water…

Thomas: Ah, yes, well you pick it up, turn it over, and the contents pour out. Pretty easy. Pretty simple. You do it everyday with no problem. You know what a cup is, and it can really serve no other basic function. But! This is not without much training - remember when you were a kid?! Everything’s hard when you’ve never done it before.

Willie: Ok, but are these things hard for a child because physically their motor skills and muscles are weaker in comparison or is it really a matter of the fact that the skill is brand new and they have no other frame of reference to go off of?

Thomas: Ok think about giving an adult of say, age 35, drink for a glass of water for the first time. Even though they would have a fully developed muscular system, they would most certainly end up with a wet t-shirt and maybe even drop the glass completely, given the novelty of this event and at being confronted with an event so shocking as that, given that they had no grasp of the consequences of their actions.

Wille: Still, they would pick it up faster because they have had a lifetime of handling objects with fine motor skills, like writing, handling the car keys, typing on keyboards, etc.

Thomas: Point taken. And that is where I was going with this. What kinds of designs can we have that use skills that we already posses or are close enough so we can adapt them for other purposes.

Willie: Bingo!

Thomas: I like the example of a child on an iPad. One of the first things we learn early on in life is how to point and of course to touch something we see and push it over. So an iPad or iPhone touch screen (point and drag) is an extremely intuitive design, as illustrated by child’s ability to operate simple games with relative ease.

Willie: So why can’t grandma work it?!

Thomas: Well that’s another story ha!

[more loud laughter, and an old lady scowls, clutches her things and slides away from them on the subway seat]

Willie: Hey what’s that?!

[Willie points across the subway to a moving image that seems like it’s coming out of no where from the darkness of the subway tunnel]

Thomas: Oh wow, another great design! Kind of like the previous example, except this takes almost no effort whatsoever. It’s purely visual.

[they are seeing a set of moving images in the subway tunnel, displayed vertically in short segments. As the subway car advances, the segments blur and a fun scene of colored characters dance and sway]

Thomas: In this case, we don’t even have to move - the subway takes care of that for us!

Willie: Ok, so what about something more complex. What is something you have thought to design that would take some learning or was maybe too complex to design?

Thomas: Well, there are certainly complex things that one can master in life where the payoff. Take driving for instance…

Willie: Sure.

Thomas: One design of my own that I had in mind after one of our first PCOMP readings about hands was a hand-held keyboard design where in each hand was a form-fitted grip, almost like egg-like in shape. The user would click with each of the five fingers on a small, round, mouse-like button in certain combinations to produce the letters and symbols on the basic keyboard. You could liken the mechanism to that of learning the recorder in band class as a youth.

Willie: Oh Lord, I was terrible at that!

[again with the laughter]

Thomas: Yea, here let me get my notebook… Here is a drawing:

[pulls out drawing with copious notes and illegible writing]

Willie: Ok, I see what you’re going for here, but don’t we already have a keyboard that seems to work just fine?

Thomas: Yea, that’s the thing. The trade off between increased typing speed and the time it takes to learn a whole new system may not be worth it. I was thinking those with carpal tunnel syndrome or perhaps some disability that excluded them from approaching a regular keyboard…

Willie: But now your just reaching…

Thomas: Yea, no pun intended!

[more laughter abounds as the train finally comes to a stop]

Making A Combo Lock

For the next PCOMP lab, I made a combination lock that would “open” (light a green LED) after the button was pressed four times. This was not that hard to set up on the bread board as much as getting the programming right. The logic and syntax was pretty new to me, but Jeff was kind enough to offer just enough advice to let me figure it out. The big revelation was using currentButtonState and previousButtonState as a way to track the state of the button, mainly if the state had changed at any moment since the loop restarted ( previousButtonState = currentButtonState; ). This gave the loop a sense of incremental time so that the number of button presses (or state changes) could be counted by incrementing the pressCount variable inside of an IF statement.

Here is the code:

// a combination lock which opens after 4 button presses
//three LEDs, one switch

int switchPatch = 2;
int yellowLED = 3;
int redLED = 4;
int greenLED = 5;
int currentButtonState;
int previousButtonState;
int pressCount = 0;


void setup() {
  pinMode(switchPatch, INPUT);
  pinMode(yellowLED, OUTPUT);
  pinMode(redLED, OUTPUT);
  pinMode(greenLED, OUTPUT);
  Serial.begin(9600);
}

void loop() {

  //read the button at dig pin 2
  currentButtonState = digitalRead(switchPatch);
  //if the state of the button changes
  if (currentButtonState != previousButtonState) {
    // and if the currentButtonState is not equal to the previous state
    // the button has either been pressed or released (something has changed)
    // so if the button stage has changed AND that state reads HIGH, then
    // the button has been pressed
        if (currentButtonState == HIGH) {
          // so turn on the yellowLED
          digitalWrite(yellowLED, HIGH);
          // and turn off the redLED
          digitalWrite(redLED, LOW);
          // and increase pressCount to track how many times this will happen
          pressCount++;
          } else {
            //otherwise the button has not been pressed
            // so keep the red LED on and yellow off
            digitalWrite(redLED, HIGH);
            digitalWrite(yellowLED, LOW);
            }
        }
    // if we press the button 4 times then...
    if (pressCount == 4) {
      //turn the green led ON
      digitalWrite(greenLED, HIGH);
      // and reset the counter
      pressCount = 0;
      } else {
        // otherwise keep the green LED off
        digitalWrite(greenLED, LOW);
        }
    // make the currentButtonState = to the previousButtonState just before
    // the loop starts over
    previousButtonState = currentButtonState;
    // print the pressCount value in the Serial Monitor
    Serial.print(pressCount);
} 

Making A Switch

Led GIF-downsized_large.gif

At first, I used a switch from my Arduino kit in class to light an LED. Then I saw everyone else’s projects and decided to go for something more interesting...

So I thought of using the piezo pickup in my Arduino kit to turn an LED on and off, like my version of The Clapper. I knew this would take some programming so I opened my Arduino Starter Kit Book and flipped to a project that had the piezo involved. I set the whole thing up and programmed the lines, even though I quickly realized that what they were showing were predicated on the previous 12 projects - it was all over my head mostly. But I got the code to verify, after a few fixes. And then it wouldn’t load to the Arduino!!! So after 45 minutes of setup and programming, the damn thing would work. I tried pressing the reset button, loading the most basic program, but that didn’t work either. So I packed it up and went to dinner defeated :-/

When I came back, I decided to at least make something so I was going to make a version of what most folks were up to with the copper tape. It would be a switch that doubled as a bookmark. When the book was open, the switch would not connect, and this would trigger a light to come on and when the book was closed, the light would turn off. This too would take some programming I realized, so I thought to leave the programming for later and at least get the switch done.

But it turns out there were all out in the shop! As I walked back to make a cup of tea, I saw the empty peanut butter jars and the idea occurred to use the aluminum from the fresh seal on the top of the jar. I could fold it onto itself and see if I could get it to conduct.

IMG_9799.JPG

I grabbed a few for testing and found here was a thin plastic coating on one side and a thicker paper coating that had been glued on to the other side. I did some testing and found the small aluminum layer material to be conductive indeed so I used an Exacto knife to removed the paper layer, revealing the aluminum in two spots on each side. I then removed a strip of aluminum running down the middle so that I had two pieces, but left the paper layer in tact so it would still fold. I did one test using solder to attach the wires, but I found the aluminum to be terribly difficult to solder on to. I decided to weave the wire through the layers a few times, poking some holes along the way, which worked out ok.

Then the switch was having trouble lighting once it was in the book because of the thickness of the wires holding the pages apart, so I taped some tabs onto the back of the exposed aluminum and the contact was made rather well.

The bookmark idea is still in tact, but I’ll need to do learn some programming first!

Prophet 600 GliGli Teensy++ Mod

Prophet600

I did the Prophet 600 GliGli mod last year and it did wonders for my Prophet.  The instructions on the website are clear and straightforward for the most part.  The programming was simple copy and past and the soldering was very basic.  The tricky part for me was getting the original chip out of the Prophet as I didn't have the right tool - an IC Puller.  I had to work pretty hard to get the chip out without damaging it.  🤦  But once it was out, popping the Adafruit Teensy++ in was easy.  

The documentation and manual for the new features are sparse.  I wish the programmer had gone into a little more effort to explain the functioning in a user friendly way, but this is not a beginner's project anyways, so I guess you can't have it both ways.  They did go to the effort of recreating all the original presets, which I can agree sound very similar.  There is a bit of me that worries that I will be in a jam if something breaks, but I do still have to original chip somewhere.