Aarnav Patel

Artist Statement: 

What does it mean to compute reality? How can our perception of the world around us be translated in a way that encourages conversation and enables creation? This is the basis of the Color-Me-Out, a compass that allows people to compute the physical colors of drawings and scribbles (our interpretations/perceptions of reality) and output them as a gradual light output. Built as a tool for children, the Color-Me-Out makes scribbling a more collaborative and conversational practice, rather than a solitary one of a person with their own paper. How can our drawings merge to create stories, and how can we perceive them through this device? 

Understanding the Sensor: 

For the first part of the project, I needed to get comfortable with using a color sensor. More importantly, what it means to use the data from that sensor in an "analog computer" way (not just binary searching but continuous input and output). As a result, I began understanding basic wiring, soldering of the sensor, and understanding the incoming data in the Serial monitor. 

From the exploration, the sensor took in 4 data values (red, blue, green, and alpha). Depending on proximity to the sensor, and brightness of the LED light attached on the color sensor, the values would fluctuate a lot. To solve the constant data fluctuation, I would loop throuhg 10 data points and find the average as a way of allowing for smoother transitions (because the sensor would occasionally jump extremely between colors). 

From there, it was just a matter of mapping these values (ranging from 300-3000 roughly) to led values on a Neopixel (0-255). However, this would result in super white colors (since adding more light makes it closer to white). with the help of some sites, I had to use something called Gamme tables, which allowed for an accurate capturing of color into light. 

Helpful Links:
https://randomnerdtutorials.com/arduino-color-sensor-tcs230-tcs3200/

https://learn.adafruit.com/adafruit-color-sensors
https://howtomechatronics.com/tutorials/arduino/arduino-color-sensing-tutorial-tcs230-tcs3200-color-sensor/

Understanding the experience: 

After getting the sensor to work, I began to think about the experience of the device itself. This led to a lot of lo-fi playtesting, and understanding what it means to move around a drawing/explore different colors. There were a lot of debates of whether I should make this a "searching" interaction, but that inherently became a binary usage of the data (if (color == found) {...}). As a result, I had to conceptually identify the project as an "exploration" device that helps people see data continouosly. 

Some of the key qualities I identified:
– Making this a shared experience – something that people can experience, but also pass off to others, be visible to others around, and something that encourages conversation/co-creation

– Making this equitable – is this a device that is fragile or durable? Something that can handle multiple users, and also not be conformed to certain people over others. 

Forming the Device: 

based on the key qualities above, I wanted this device to be something that can be held with multiple hands (not a single-hand device, or something that is hand-held because that closes it off from being used by others), and something that is also big enough to be seen by others in the experience. While I did explore some drawings with ergonomics, I ultimately landed on a purely symmetrical form to promote equitable usage.  The vibe I was going for was almost like a 'black box' compass – something you can't see into, but it outputs something (basically a computer). 

Building the Form: 

After sketching, I went into modeling the form on Rhino. While I knew that the overall form would be a cylinder, I wanted to really engineer it so that the device required no glue (After the hell that was last project). This meant making the overall form assemble-able (friction fit joint), having a rim to stick the acrylic into (another friction fit), and padding/stablizers for the sensors (namely rods for the color sensor). This required precise measurements, and some multiple tries with prints. 

Because I knew the color sensor had a built in LED, I could put it at the bottom of the form and and still get it to accurately catpure the color underneath it. Additionally, I built a 0.5in depth for capturing color (since that was an accurate distance range for the sensor based on initial explorations). 

Reflection:
Overall, I struggled with accepting the simplicity of the project. However, it allowed me to really refine certain things i never got to do during the last project. 

1) Soldering onto a mini-bread board. This was my first time and it worked successfully. I got to understand how to connect an Arduino/sensors/outputs to a breadboard. This helped me make a compact design. 

2) Assembly. I really wanted to focus on having a clean assembly that I could easily replicate for the future of this project (since I wanted a product system). As a result, I focused a lot more time on the 3D model, understanding how friction fits would work, and creating interior structures to case/protect the sensors/computing. 

3) Understanding a new sensor – I was able to look online and interpolate data from sources as a beginner which is extremely empowering as a beginner. It makes me ambitious to learn and try out new sensors. 

#include <Adafruit_TCS34725.h>

#include <Adafruit_NeoPixel.h>

// NeoPixel setup

#define PIN            10  // Define the pin for the NeoPixel strip

#define NUMPIXELS      30  // Define the number of NeoPixels in the strip

Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

// TCS34725 setup

Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);

int numPixels = 30;

int illuminationLed = 9;

int breath = 51;

int increment = 1;

// Set to true if using a common anode LED

#define commonAnode true

byte gammatable[256];

void setup() {

 Serial.begin(9600);

 pinMode(illuminationLed, OUTPUT);

 if (tcs.begin()) {

   // Serial.println("Found sensor");

 } else {

   Serial.println("No TCS34725 found ... check your connections");

   while (1); // halt!

 }

 // NeoPixel initialization

 strip.begin();

 strip.show();  // Initialize all pixels to 'off'

 // Gamma correction table

 for (int i = 0; i < 256; i++) {

   float x = i;

   x /= 255;

   x = pow(x, 2.5);

   x *= 255;

   gammatable[i] = x; //DO THIS!

   }

}

void loop() {

 float red, green, blue;

 tcs.setInterrupt(false);  // turn on LED

 delay(60);  // takes 50ms to read

 tcs.getRGB(&red, &green, &blue);

 tcs.setInterrupt(true);  // turn off LED

 analogWrite(illuminationLed, 10);

 Serial.print("R:\t"); Serial.print(int(red));

 Serial.print("\tG:\t"); Serial.print(int(green));

 Serial.print("\tB:\t"); Serial.print(int(blue));

 Serial.print("\n");

 // Example: Set the first NeoPixel color using gamma correction

 for (int i = 0; i < numPixels; i++) {

   strip.setBrightness(breath);

   strip.setPixelColor(i, strip.Color(

     gammatable[(int)red],

     gammatable[(int)green],

     gammatable[(int)blue]

   ));

 }

 if (breath >= 255 || breath <= 50) {

   increment = -increment;

 }

 breath += increment;

 Serial.println(breath);

/*

   for (int i = 0; i < 10; i++) {

   strip.setPixelColor(i, strip.Color(

     red,

     green,

     blue

   ));

 }

 */

 strip.show();  // Send the updated color to the NeoPixel

}