Counting to a Billion is a device created to fulfill the desire to count. The electronics consists of a microcontroller, a speech module, and a speaker powered by a rechargeable battery. There is no/off switch. The voice will keep counting when the device is unplugged and if the battery is drained, the count will pick up where it left off when the battery recharges. The voice begins counting at one, two, three and continues counting up until it reaches one billion at which point in time it will stop.

If it took a second to utter each string of numbers, it would take 1 billion seconds or 31.7 years for the device to reach its end. But since it takes more than a second to vocalize many of the numbers in the sequence, it may take upwards of 60 years to complete.

The unit is housed in a solid block of aluminum, cnc milled into a vessel that was designed to withstand substantial abuse over many years.

Counting to a Billion is for sale as an edition of 5.

Materials: Aluminum, custom electronics
Dimensions: 4” (10cm) diameter, 6” (15cm) height, freestanding

Counting to a Billion from che-wei wang on Vimeo.

Galvanic skin response readings are simply the measurement of electrical resistance through the body. Two leads are attached to two fingertips. One lead sends current while the other measures the difference. This setup measures GSR every 50 milliseconds. Each reading is graphed, while peaks are highlighted and an average is calculated to smooth out the values. A baseline reading is taken for 10 seconds if the readings go flat (fingers removed from leads).

GSR Reader from che-wei wang on Vimeo.

GSR readings in processing from che-wei wang on Vimeo.

Arduino Code:

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

void loop(){
  int a=analogRead(0);
  if (Serial.available() > 0) {

    byte inbyte=Serial.read();
    if(inbyte=='a'){
      Serial.print(a,BYTE);

    }
  }
}

Processing Code:

import processing.serial.*;
Serial myPort;  

int hPosition = 1;     // the horizontal position on the graph
float currentReading;
float lastReading;
int count=0;
int zeroLinePos=0;

float gsrAverage,prevGsrAverage;
float baseLine=0;
long lastFlatLine=0;
color graphColor=color(255,255,255);
int baselineTimer=10000;
int gsrValue;
int gsrZeroCount=0;
float gsrRange=0;
int downhillCount=0;
int uphillCount=0;
boolean downhill;
boolean peaked=false;
float peak, valley;

void setup () {
  size(900, 450);
  // List all the available serial ports
  //println(Serial.list());

  myPort = new Serial(this, Serial.list()[0], 9600);
  currentReading=0;
  lastReading=0;
  gsrAverage=0;
  background(0);

  smooth();
}

void draw () {
  //best delay setting for gsr readings
  delay(50);
  //image(myMovie, 0, 0);

  if (gsrValue<15 &&gsrValue>-15){
    if( gsrZeroCount>10){
      currentReading=0;//flatline
      gsrAverage=0;
      baseLine=0;
      lastFlatLine=millis();
      gsrZeroCount=0;
      // println("reset");

    }
    gsrZeroCount++;
  }
  else{
    currentReading=gsrValue-baseLine;
    gsrZeroCount=0;
  }

  if(millis()-lastFlatLine>baselineTimer){
    baseLine=gsrAverage;
  }

  //graph colors
  if(gsrAverage>0 && gsrAverage<height/2.0*.25) graphColor=color(255,255,255);
  else if(gsrAverage>height/2.0*.25 && gsrAverage<height/2.0*.5) graphColor=color(255,250,100);
  else if(gsrAverage>height/2.0*.5 && gsrAverage<height/2.0*.75) graphColor=color(255,250,0);
  else if(gsrAverage>height/2.0*.75) graphColor=color(255,100,0);

  gsrRange=peak-valley;

  // at the edge of the screen, go back to the beginning:
  if (hPosition >= width) {
    hPosition = 0;

    //cover last drawing
    fill(0,200);
    noStroke();
    rect(0,0,width,height);
  }
  else {
    hPosition+=1;
  }

  gsrAverage=smooth(currentReading,.97,gsrAverage);

  //draw stuff

  //spike
  noStroke();
  if(gsrRange>200){
    fill(255);
    ellipse(10,10,20,20);
  }
  else{
    fill(0);
    ellipse(10,10,20,20);
  }

  //graph
  strokeWeight(.5);
  stroke(graphColor);
  line(hPosition-1, height/2.0-lastReading, hPosition, height/2.0-currentReading);
  stroke(255,0,100);
  line(hPosition-1,height/2.0-prevGsrAverage,hPosition,height/2.0-gsrAverage);

  //draw peaks
  int thres=7;

  noFill();
  stroke(255,0,0);
  strokeWeight(2);

  if (currentReading-thres>lastReading&& peaked==true){
    downhill=false;
    //println(downhillCount);
    uphillCount++;
    downhillCount=0;
    point(hPosition-1, height/2.0-lastReading);
    valley=lastReading;
    peaked=false;

  }
  if(currentReading+thres<lastReading && peaked==false){
    //println(uphillCount);
    downhill=true;
    uphillCount=0;
    downhillCount++;
    point(hPosition-1, height/2.0-lastReading);
    peak=lastReading;
    peaked=true;
  }

  prevGsrAverage=gsrAverage;
  lastReading=currentReading;
  //send 'a' for more bytes
  myPort.write('a');
}

void serialEvent (Serial myPort) {
  int inByte=myPort.read();
  //0-255
  gsrValue=inByte;
}

void keyPressed(){
  if (keyCode==DOWN)zeroLinePos+=3;
  if (keyCode==UP)zeroLinePos-=3;

  strokeWeight(1);
  stroke(255,0,0);
  line(0,zeroLinePos,2,zeroLinePos);
}

int smooth(float data, float filterVal, float smoothedVal){
  if (filterVal > 1){      // check to make sure param's are within range
    filterVal = .99;
  }
  else if (filterVal <= 0){
    filterVal = 0;
  }
  smoothedVal = (data * (1 - filterVal)) + (smoothedVal  *  filterVal);
  return (int)smoothedVal;
}

Here’s the first test with Ornos. The compass readings are behaving pretty well considering it’s right underneath a spinning hard drive. The 1.2Ghz processor and 512 RAM don’t seem to be enough to download and render the image quickly enough, so I’m going to have to figure out how to speed things up.

Ornos : Prototype 01 from che-wei wang on Vimeo.

Here’s some example Arduino code for getting a Etek EB-85A module up and reading latitude and longitude (will probably work with most GPS modules). You can purchase a module from Sparkfun.

The module only needs power, ground, rx and tx. Most modules like the Etek start sending NMEA strings as soon as it has power. The Etek module takes a minute or two to get a satellite fix from a cold start in urban environments. Signals drop out once in a while between tall buildings at street level even with DGPS and SBAS. On a clear day, if you’re lucky, you can get a signal sitting by the window in urban canyons.

//Etek GPS EB-85A Module Example
//by Che-Wei Wang and Kristin O'Friel
//32 Channel etek GPS unit
//modified from original code by Igor González Martín. http://www.arduino.cc/playground/Tutorials/GPS
boolean startingUp=true;
boolean gpsConnected=false;
boolean satelliteLock=false;

long myLatitude,myLongitude;

//GPS
#include <string.h>
#include <ctype.h>
int rxPin = 0;                    // RX PIN
int txPin = 1;                    // TX TX
int byteGPS=-1;
char linea[300] = "";
char comandoGPR[7] = "$GPRMC";
int cont=0;
int bien=0;
int conta=0;
int indices[13];

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void setup() {
  //GPS
  pinMode(rxPin, INPUT);
  pinMode(txPin, OUTPUT);

  for (int i=0;i<300;i++){       // Initialize a buffer for received data
    linea[i]=' ';
  }
    Serial.begin(4800);
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void printInfo(){

  Serial.print("myLat: ");
  Serial.println(myLatitude);
  Serial.print("myLong: ");
  Serial.println(myLongitude);

  if(gpsConnected==true){
    Serial.println("GPS connected");
  }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//convert NMEA gps syntax of degrees and minutes to + or - decimal point degrees
long decimalMinutes( long l, char dir){
  //latitude ddmmmmmm
  //longitude dddmmmmmm
  long decimal;                 //ddmmmmmm
  float ll=(float)l/1000000.0;  //dd.mmmmmmm
  int dd=floor(ll);             //dd.mmmmmm
  float mmmmmm=(ll-dd);         //  .mmmmmm
  float dddddd=mmmmmm/6.0*10.0; //  .mmmmmm convert minutes to decimal degrees .dddddd
  decimal=(float)(dd+dddddd)*1000000.0;

  if(dir=='W'||dir=='S')decimal=decimal*-1.0;
  return decimal;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void readGPS() {
  byteGPS=Serial.read();         // Read a byte of the serial port
  if (byteGPS == -1) {           // See if the port is empty yet
    //delay(100);
    gpsConnected=false;
  }
  else {
    gpsConnected=true;
    linea[conta]=byteGPS;        // If there is serial port data, it is put in the buffer
    conta++;                      

    //printByte(byteGPS); //print raw rx

    if (byteGPS==13){            // If the received byte is = to 13, end of transmission
      cont=0;
      bien=0;
      for (int i=1;i<7;i++){     // Verifies if the received command starts with $GPR
        if (linea[i]==comandoGPR[i-1]) bien++;
      }

      if(bien==6){               // If yes, continue and process the data
        for (int i=0;i<300;i++){
          if (linea[i]==','){    // check for the position of the  "," separator
            indices[cont]=i;
            cont++;
          }
          if (linea[i]=='*'){    // ... and the "*"
            indices[12]=i;
            cont++;
          }
        }

        //satellite lock
        char satLock;
        for (int j=indices[1];j<(indices[2]-1);j++){
          // Serial.print(linea[j+1]);
          // Serial.println("");
          if(linea[j+1]=='V')satelliteLock=false;
          else satelliteLock=true;
          satLock=linea[j+1];
        }

        //latitude
        char NS;
        char tempLat[9];
        int tempLatCount=0;
        for (int j=indices[2];j<(indices[3]-1);j++){
          //print raw
          if(linea[j+1]!='.'){//remove decimal
            //Serial.print(linea[j+1]);
            tempLat[tempLatCount]=linea[j+1];
            tempLatCount++;
          }
        }

        //Serial.println("");
        for (int j=indices[3];j<(indices[4]-1);j++){
          //Serial.println(linea[j+1]);
          NS=linea[j+1];
        }

        // myLatitude=strtol(tempLat);
        long myLat=strtol(tempLat, NULL, 10);
        //convert degrees and minutes to decimal degrees
        myLatitude=decimalMinutes(myLat,NS); 

        //longitude
        char EW;
        char tempLong[10];
        int tempLongCount=0;

        for (int j=indices[4];j<(indices[5]-1);j++){
          //print raw
          if(linea[j+1]!='.'){//remove decimal
            //Serial.print(linea[j+1]);
            tempLong[tempLongCount]=linea[j+1];
            tempLongCount++;
          }
        }
        //Serial.println("");

        for (int j=indices[5];j<(indices[6]-1);j++){
          // Serial.println(linea[j+1]);
          EW=linea[j+1];
        }

        long myLong=strtol(tempLong, NULL, 10);
        //convert degrees and minutes to decimal degrees
        myLongitude=decimalMinutes(myLong,EW);

        if (startingUp){
          //gps setup strings for Etek GPS modul
          Serial.print("$PMTK501,2*28rn");//turn on dgps
          Serial.print("$PMTK313,1*2Ern");//turn on sbas
          Serial.print("$PMTK314,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29rn");//gprmc only
          startingUp=false;
        }
      }
      conta=0; // Reset the buffer
      for (int i=0;i<300;i++){
        linea[i]=' ';
      }
    }
  }
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void loop() {
  readGPS();
  printInfo();
  //do stuff here
  //myLatitude is a long like 40689667 which is 40.689667 degrees
  //or -73946641 which is -73.94641

}

I was going to cover the lasercut masonite with a leather sleeve, but I’m going to go with cnc milled RenShape with a painted finish for the next prototype. The compass needs to be calibrated to the offsets caused by the magnetized computer hardware and I need to tweak some code to get the frames to load faster and smoother. I’ll post a video as soon as that part is worked out.

So far, the Arduino reads the x and y tilt values and translates them into motion across 4 servos to maintain a horizontal platform at the top. Next, I need to get the z tilt values to reverse the x and y tilts, so you can tilt the whole thing up side down and still have the top platform facing up.

Accelerometer + 4 servo motors from che-wei wang on Vimeo.

Since the first hand drawn maps of the stars to satellite imagery and GPS navigation today, our frame of reference and our perception of space has been molded into a view from above. Our understanding of place is often linked to an abstract representation on a map rather than a physical relational comprehension. You could probably point out Azerbaijan on a map, but how many of us can simply point in its direction across the globe? The image of the globe projected onto a vertical surface is so pervasive, we often associate “up” with north as we project ourselves into a mental image of map.

The accessibility of GPS and online map services have continued to reinforce the “up” vector while creating a greater divide between the physical world and its virtual representations. Today, we view from above, as primarily experienced on our screens, in an elevation view without any regard to its physical context. We project our presence into the screen through multiple translations of orientation. Viewing a map on a computer screen requires one to find a location on the screen that represents a position, then the abstracted orientation of the vertical screen must be translated and scaled into the physical context of the current position. We’ve lost a step in comprehension without the compass and the horizontal map. The traditional map and compass gave an intuitive understanding of a current position in relation to physical space by rotating the map to align with the space it represented. What appeared one inch to the left of my location on the map could be confirmed by looking up to my left.

Ornos is a telescopic view from above. The horizontal screen reconstructs a view from a position directly above itself using satellite imagery and maps. Exploring your current surroundings is as simple as sliding the device on any surface to pan across the globe. Zooming is controlled by rotating the device itself. The onboard digital compass and GPS modules orient the image on the screen to reflect your physical surroundings while satellite imagery and maps are dynamically loaded from Google, Microsoft, or Yahoo.

Ornos : Prototype 01 from che-wei wang on Vimeo.

Here’s the first test with Ornos. The compass readings are behaving pretty well considering it’s right underneath a spinning hard drive. The 1.2Ghz processor and 512 RAM don’t seem to be enough to download and render the image quickly enough, so I’m going to have to figure out how to speed things up.

//heading calcuations added from Daniel's processing code to get a heading value of 0-3600 in Arduino
//edited by Che-Wei Wang
//tested on MICROMAG 3-AXIS V1.00
//clockwise rotation is positive

//Original Arduino code for controlling a MicroMag3 magnetometer through SPI
//by Daniel Soltis

#define SCLK 7 //the clock to pulse (#1 on breakout)
#define MISO 6 //master in, slave out (#2 on breakout)
#define MOSI 5 //master out, slave in (#3 on breakout)
#define SSNOT 4 //when low, the device is enabled (#4 on breakout)
#define DRDY 3 //this is low after a reset, high when data is ready (#5 on breakout)
#define RESET 2 //this needs to be toggled low-high-low before each measurement (#6 on breakout)

#include <math.h>

int x = 0;
int y = 0;
int z = 0;
int heading = 0;

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

  pinMode(SSNOT, OUTPUT);
  pinMode(RESET, OUTPUT);
  pinMode(MOSI, OUTPUT);
  pinMode(MISO, INPUT);
  pinMode(DRDY, INPUT);
  pinMode(SCLK, OUTPUT);

  //i could just ground this line, but this at least marks it as
  //something that one could change if needed
  digitalWrite(SSNOT, LOW);
}

void loop(){

  x=readaxis(0);
  y=readaxis(1);
  z=readaxis(2);
  getHeading(x,y,z);

}

void send_bit(int _high){

  //this sends the bit on the rising edge of the clock

  digitalWrite(MOSI, _high);
  delay(2);
  digitalWrite(SCLK, HIGH);
  delay(2);
  digitalWrite(SCLK, LOW);
  delay(2);
}

int receive_bit(){

  //this receives the data on the falling edge of the clock

  digitalWrite(SCLK, HIGH);
  delay(2);
  int bit = digitalRead(MISO);
  delay(2);
  digitalWrite(SCLK, LOW);
  delay(2);
  return bit;
}

float readaxis(int _axis){
  //this function sends eight bits, waits until the data is ready
  //and receives 16 bits

    //pulse the reset
  digitalWrite(RESET, LOW);
  delay(2);
  digitalWrite(RESET, HIGH);
  delay(2);
  digitalWrite(RESET, LOW);
  delay(2);

  //send the command byte

  //this sends data that we are not in debug mode
  //and sets the amount of time to read the magnetic sensors (the ASIC period)
  //as /2048
  send_bit(LOW);
  send_bit(HIGH);
  send_bit(HIGH);
  send_bit(LOW);
  send_bit(LOW);
  send_bit(LOW);

  //the last two bits select the axis
  if (_axis == 0){ //x axis
    send_bit(LOW);
    send_bit(HIGH);
  }
  else if (_axis == 1){ //y axis
    send_bit(HIGH);
    send_bit(LOW);
  }
  else{ //z axis
    send_bit(HIGH);
    send_bit(HIGH);
  }

  //wait until the drdy line is high
  while (digitalRead(DRDY) == LOW){
    //wait
    //Serial.println("waiting");
  }
  //Serial.println("data!");

  long runningtotal = 0;

  //receive the results and tally them up as they come in 

  //the leftmost bit signs the number as positive or negative
  long sign = receive_bit();

  //the remaining bits need to be translated from individual bits into an integer
  for (int i = 14; i >= 0; i = i - 1){
    long thisbit = receive_bit();
    thisbit = thisbit << i;
    runningtotal = runningtotal | thisbit;
  }

  if (sign == 1){
    runningtotal = runningtotal - 32768;
  }

  //this sends the data over the serial line, as a string separated by commas
  if (_axis == 0){
    x = runningtotal;
    Serial.print(x,DEC);
    Serial.print(44, BYTE);
  }
  else if (_axis == 1){
    y = runningtotal;
    Serial.print(y,DEC);
    Serial.print(44, BYTE);
  }
  else{
    z = runningtotal;
    Serial.print(z,DEC);
    Serial.print(44, BYTE);
  }
  return runningtotal;
}

int getHeading(float x, float y, float z){
  int heading=0;
  if (x==0 && y<0) heading=900.0;
  if(x==0 && y>0) heading=2700.0;
  if (x < 0) heading = (PI - atan(y/x))/TWO_PI*3600.0;
  if (x > 0 && y < 0) heading = (-1*atan(y/x))/TWO_PI*3600.0;
  if (x > 0 && y > 0) heading = (2.0*PI - atan(y/x))/TWO_PI*3600.0;
  Serial.print("heading: ");
  Serial.println(int(heading));
  return heading;
}

AGS aka Haiku Shake is a haiku generator. Tilting to the left begins the trickling of the haiku. Each haiku is generated randomly based on 3 haiku forms and a set of preselected words. To generate a new haiku, just shake it.

Ags has 3 haiku forms along with a list of words hard coded onto the chip. Each shake generates a random selection of words to fit the 5 7 5 syllable format as well as 3 predetermined haiku forms.

form1:
article adjective noun
article noun verb preposition article noun
adjective adjective noun

form2:
noun preposition article noun
article adjective noun preposition article noun
adjective noun

form3:
article adjective adjective noun
preposition article adjective noun
article noun verb

Examples of some randomly generated haikus from Ags:
either funny hand
a bank flies on which treasure
constant brutal hand

this perfect grapefruit
a grapefruit brings for this tree
warming smiling clown

sea on a flower
which hidden beat with a clown
warming harmony

a patient light sky
but a perfect umbrella
flowing flower hugs

which pretty white rain
against a pretty puddle
hidden puddle

gate for either dish
which brutal breeze through that room
smiling umbrella

a forgiving sky
a spoon juggles but a clown
warming constant sky

Verson 02 features:
-expanded word set (80 nouns, 40 adjs, 60 verbs, 7 articles, and 20 preps)
-uses flash memory on chip to store words (PROGMEM)
-syllable checking for haiku form
-3 haiku forms
-simple article choosing function between ‘a’ or ‘an’ before vowels
-trickling text based on tilt
-shake sensor to generate a new haiku

AGS : Haiku Shake V02 from che-wei wang on Vimeo.

Components:
Arduino Mini
Accelerometer
SerLCD 2.5
1 AA battery stepped up to 5VDC
Toggle switch
Altoids tin
Arduino Code : haikushake10forms.pde

4 layers of industrial felt hold all the pieces together. 4 AA Batteries, one arduino with an accelerometer and an LCD panel.

AGS : Haiku Shake V01 Felt Shell from che-wei wang on Vimeo.