As an Industrial Designer I live in a world of creation dictated by usefulness, sleekness, and functionality. However, I have always been fascinated by objects that at first seem useful but in the end show how incredibly useless they truly are. My journey into objects that are useless in not any easy one, my formal training and continued professional practice make it difficult for me to produce an object for the sake of that object. I challenged myself to take an object that most people can relate to and also understand the usefulness on first glance. Upon further inspection of the object, in this case a lamp, the user realizes the uselessness of the object. 

I took visual inspiration from the concrete usage in Russian Architecture and contrasted it with copper, a material that exists in a dichotomic state being both cold and visually warm. So the bones of this object have come together to form something of interest slightly not square and imperfect in so many ways. The viewer is forced to reconcile the uneasy feeling of something that is seemingly unbalanced. The Lamp shade, angled back towards the base of the object puts a focus on the users hands as they interact with two metal protrusions from the base. These metal posts are points of interaction, no adjustability to the positioning of the light is offered, no ability to change the height the light, it is simply there.

As I mentioned in my previous entry, my original intention was to use gesture control to change position of the lens as well as the brightness of the light. Below is the code that attempts to limit a stepper motor to have only 90 degrees of rotation. For some reason the stepCount variable would not update while using the APDS9960 gesture sensor. I gained two very important pieces of information from this lengthy process. 

1. Just because an interaction makes sense in your head does not mean it will be the most effective. After spending some time with a few different users I abandoned the use of the gesture sensor, It was mostly just frustrating. It was very unpredictable, it worked 100% of the time 10% of the time, in other words it didn’t really work at all. From miss-reading the gesture to not picking up the gesture at all, it just didn’t make sense to use it in this case. I think the sensor works OK sometimes however, to use it on a lamp makes it quirks really err…shine. Having the sensor placed anywhere that made sense for the operation of the lamp made its performance suffer even more.
2. Don’t use a stepper motor when you really need a servo. Steppers are great for very precise movements, something I did not need in this situation. Steppers are also great for a device that needs continuous rotation, again I did not need continuous rotation I only needed 90 degrees. The use of the servo and a radial potentiometer really gives the user a connected feel to the movement of the lens.

Below is the code for using the gesture sensor to control the stepper.

#include "Stepper.h"
#include "Adafruit_APDS9960.h"
Adafruit_APDS9960 apds;

int stepCount = 0;
const int stepsPerRevolution = 1026;  // change this to fit the number of steps per revolution
// for your motor

// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 9, 10, 11, 12);

void setup() {
  // set the speed at 60 rpm:
  myStepper.setSpeed(10);
  // initialize the serial port:
  Serial.begin(9600);

  if (!apds.begin()) {
    Serial.println("failed to initialize device! Please check your wiring.");
  }
  else Serial.println("Device initialized!");

  //gesture mode will be entered once proximity mode senses something close
  apds.enableProximity(true);
  apds.enableGesture(true);
}

void loop() {
  // step one revolution  in one direction:
  //  uint8_t gesture = apds.readGesture();
  if (stepCount < 510) {
    uint8_t gesture = apds.readGesture();
    if (gesture == APDS9960_DOWN) myStepper.step(51);
    stepCount = stepCount + 51;
    delay(100);

    if (gesture == APDS9960_UP) myStepper.step(-51);
    stepCount = stepCount - 51;
    delay(100);



    //  if (gesture == APDS9960_LEFT) myStepper.step(513);
    //  if (gesture == APDS9960_RIGHT) myStepper.step(-513);
    Serial.print("stepCount:");
    Serial.println(stepCount);
  }

}

Conceptually the idea is to have a lamp that really only functions as an interaction with the lamp. Basically a useless lamp. Brightness is controlled via a rotary potentiometer placed on the left-hand side of the base and the lens position is controlled by a rotary potentiometer placed on the right-hand side of the base. There is a bit of discovery involved as the pots are not labeled on purpose. At this point you might be asking yourself “Why would I want/need to control the position of the lens?” Well ,my friend, I’ll tell you. This particular lamp has not one but two lenses, each lens is a composite of a lenticular array and a linear polarizing filter. The idea was to change the relative position of the lenses to change the light quality. What I basically ended up doing, not on propose I might add, was creating a variable detraction grating. This was not my intended outcome however, my goal was to change the quality of the light by rotating two lenses in relation to each other. In that sense I was fully successful in that goal.

so now lets look at the code I used for the final implementation, two variables allow the position of the lens and the brightness to be adjusted independently of each other.

#include <Servo.h>

Servo servoMotor;
int servoPin = 3;
const int lampPin = 9;    

void setup() {
  Serial.begin(9600);
  pinMode(lampPin, OUTPUT);
  servoMotor.attach(servoPin);
}

void loop() {
//  Lamp Operation
 int sensorValue = analogRead(A0);
   int outputValue = map(sensorValue, 0, 1023, 50, 255);
   analogWrite(lampPin, outputValue); //Adjust Lamp Brightness
   Serial.println(outputValue);

//Servo Operation 
  int analogValue = analogRead(A1);
  int servoAngle = map(analogValue, 0, 1023, 0, 95);
if (millis()% 20 <2) {
  servoMotor.write(servoAngle);//Change Postion of Servo
  
}  
Serial.println(servoAngle);
}