When considering what to do for the creative part of my Physical Computing lab, I initially thought of some sort of mood-proclaiming piece of clothing.
Instead of using a flex or pressure sensor to light up the LEDs on a "luv-o-meter," I wanted to prototype a display for a t-shirt that could display a short and partially encrypted message about the wearer's stress level. I remember seeing a
persistence of vision project on one of my first trips to ITP (perhaps it was the winter show?) and thought I might be able to make a single column of LEDs light up and scroll the message past.
Using only a slightly modified version of the circuit from my game of catch, I set about drafting some code to drive a vertical array of 5 LEDs.
(written during experimentation)
- First attempt unsuccessful... I tried moving my head back and forth to see the image, but didn't get to a point where I could see the image persisting. In the interest of time, though, I'm going to try a couple more speeds before I set about rewiring
- I added potentiometers to the circuit in order to vary the delay between the columns of the character as well as between each letter. When I move the board back and forth I can make out the characters, but it seems like they might be going backwards.
- Seems like the rocking back and forth I'm doing may be causing the character to be rendered backwards. On the bicycle example, the direction is constant. I wonder how the clock I've seen that uses this trick works... it swings back and forth... perhaps it has to write the characters in reverse order...
I could eventually try mounting this contraption on a motor
/* ----------------------------------------
Persistence
----------------------------------------
Michael Chladil
Physical Computing
2006-09-23
written for Arduino v1.18
----------------------------------------
*/
#include
#define DEBUG_LVL 1
// Going to try first with 5-line characters
#define CharacterPin1 3
#define CharacterPin2 4
#define CharacterPin3 5
#define CharacterPin4 6
#define CharacterPin5 7
#define CHAR_WIDTH 5
#define CHAR_HEIGHT 5
byte Letter_M[CHAR_WIDTH][CHAR_HEIGHT] = { {1, 0, 0, 0, 1},
{1, 0, 0, 0, 1},
{1, 1, 0, 1, 1},
{1, 0, 1, 0, 1},
{1, 0, 0, 0, 1} };
byte Letter_C[CHAR_WIDTH][CHAR_HEIGHT] = { {0, 1, 1, 1, 1},
{1, 0, 0, 0, 0},
{1, 0, 0, 0, 0},
{1, 0, 0, 0, 0},
{0, 1, 1, 1, 1} };
#define CharacterPin6 8
#define CharacterPin7 9
#define Switch1 10
#define Switch2 11
int delayTime = 0;
int charRow = 0;
int interCharDelay = 0;
void setup ()
{
pinMode (CharacterPin1, OUTPUT);
pinMode (CharacterPin2, OUTPUT);
pinMode (CharacterPin3, OUTPUT);
pinMode (CharacterPin4, OUTPUT);
pinMode (CharacterPin5, OUTPUT);
pinMode (Switch1, INPUT);
pinMode (Switch2, INPUT);
if (DEBUG_LVL > 0)
{
Serial.begin (9600);
}
}
void writeChar (char charToWrite)
{
byte Letter[5][5];
int charCol = 0;
int charRow = 0;
int i;
// Needed a way to copy the constants I defined above without going
// pixel by pixel. memcpy seems to do the trick. I initially wanted
// to copy the entire 2-D array at once, but it didn't seem to work
// and I wanted to move on to verifying other things
switch (charToWrite)
{
case 'M' :
{
for (int i = 0; i < CHAR_HEIGHT; i++)
memcpy (Letter[i], Letter_M[i], CHAR_WIDTH);
break;
}
case 'C' :
{
for (int i = 0; i < CHAR_HEIGHT; i++)
memcpy (Letter[i], Letter_C[i], CHAR_WIDTH);
break;
}
}
for (charCol = 0; charCol < CHAR_WIDTH; charCol++)
{
for (charRow = 0; charRow < CHAR_HEIGHT; charRow++)
{
digitalWrite(CharacterPin1 + charRow, Letter[charRow][charCol]);
}
delay (delayTime);
for (charRow = 0; charRow < CHAR_HEIGHT; charRow++)
{
digitalWrite(CharacterPin1 + charRow, LOW);
}
delay (10);
}
}
void loop()
{
delayTime = analogRead(5);
interCharDelay = analogRead(4);
writeChar('M');
delay(interCharDelay);
writeChar('C');
delay(interCharDelay);
}
... and in fact it should be noted that I found a soldering problem on the little board I salvaged. Apparently when I rewired it, I knocked one of the circuit traces loose, which prevented the upper right switch from working. This caused me much consternation while trying to develop the catching algorithm. Thankfully Serial.println helped me figure things out.
I modified my program to use the upper left switch for both throwing and catching. Maybe it's not so interactive anymore, but it's done and I have other things like Spatial Design homework to do.
If you like to read source code, you can do so in the full entry.
