張旭豐

Posted on Apr 13

The Moment Your Project Knows You're There

S1: The Feeling You Want to Create

There is a moment when something changes.

You walk toward a wall, and as you get closer — something shifts. Not because you touched anything. Not because you pressed a button. Just because you were there.

That's the moment this article is about.

On Behance, there is a project called The Dots — an interactive kinetic installation by Jack Lee. Seven circular panels arranged in a hexagonal grid, each coated with polarized film. You wear a special face shield, and as you approach the panels, they begin to rotate. The closer you get, the more the panels become transparent. Step back, and they fade again. The work is called DISTANCE TO DARKNESS.

Lee describes it as "Magic of Lights." Viewers call it "mesmerising." One person wrote that standing in front of it felt like watching a "visual symphony."

You may not have the tools to build The Dots. But you can build the core feeling it captures — and it takes less than you think.

S2: What Makes It Work

The magic of The Dots is not in the servo motors. It is not in the Arduino code. It is not in the polarized film.

It is in the fact that the installation knows you are there.

That one quality — responsiveness without contact — is what separates "interactive art" from "electronics project." Anyone can make an LED blink. Making an LED respond to someone's presence, the way a living thing might — that is the thing you actually want to learn.

Here is how it works at the most basic level:

A proximity sensor emits a signal (infrared or ultrasonic) and measures how long it takes for that signal to bounce back. The closer an object — like a human body — the stronger the return signal. An Arduino reads that signal strength as a number.

That number can then be used to control something. An LED brightness. A servo rotation angle. The rate at which bubbles form in a wall. The transparency of a polarized panel.

The chain is always the same:

Proximity > Signal > Decision > Response

Your project does not need to be complex. It needs to be responsive. The moment your project reacts to the world around it — without being told what to do — it becomes something more than the sum of its parts.

S3: The Simplest Version of This Moment

You can feel this in under ten minutes.

What you will build:

A single LED that turns on when your hand gets close to a sensor. No buttons. No code you need to understand first. Just proximity — and response.

What you will need:

Arduino Uno (or Nano)
IR proximity sensor (Sharp 2Y0A21, approximately $6-10)
LED (any color)
220 Ohm resistor
Breadboard and jumper wires

That is all. No soldering. No prior experience.

The wiring:

Arduino 5V  > Sensor VCC (red wire)
Arduino GND > Sensor GND (black wire)
Arduino A0  > Sensor OUT (white/yellow wire)
Arduino D9  > LED (+) through 220 Ohm resistor
Arduino GND > LED (-) (short leg)

The code:

const int sensorPin = A0;
const int ledPin = 9;

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int value = analogRead(sensorPin);
  // With nothing nearby: value around 500-600
  // With hand 5-10cm away: value drops to 100-200

  if (value < 200) {
    digitalWrite(ledPin, HIGH); // It knows you're there
  } else {
    digitalWrite(ledPin, LOW);  // You're too far
  }
}

What just happened:

You made something that responds. Not something that runs a program you wrote. Something that reacts to the world — to you — the way The Dots does, the way Bubble Wall does, the way every interactive installation you have ever admired does.

The complexity of the project does not change this fact. A proximity-triggered LED and a wall of polarized panels operate on the same principle. The difference is only in scale.

S4: Building on That Moment

Once you have felt the basic response, you can extend it in two directions.

Scale the response:

Instead of just on/off, use PWM (Pulse Width Modulation) to make the LED fade gradually as you approach. This is how The Dots creates its smooth transitions — not sudden changes but continuous, analog-feeling responses.

int brightness = map(value, 50, 600, 255, 0);
brightness = constrain(brightness, 0, 255);
analogWrite(ledPin, brightness);

Change the trigger:

Proximity is one option. Here are other ways your project can "know" you are there:

What you want to detect	Sensor	Approximate cost
Distance / presence	IR (Sharp 2Y0A21) or Ultrasonic (HC-SR04)	$5-10
Light level in the room	Photoresistor (LDR)	under $1
Sound / clap	Electret microphone module	$2-3
Touch without contact	Capacitive touch (MPR121)	$10-15
Temperature nearby	TMP36	$1-2

Change the response:

The LED can become anything:

A solenoid pushing a physical object
A servo motor rotating a panel or arm
A valve opening to release air or mist (this is how Bubble Wall works)
A motor changing speed instead of just turning on and off

The Dots uses servo motors to rotate panels. Bubble Wall uses solenoid valves to control mist. The principle is the same — a sensor reading translated into motion.

S5: The Realization

Go back to The Dots. Read the description again:

"As the panels rotate, the relative angle between the polarised film on the panels and the viewer's face shield changes. This change in angle alters the transmission of light through the panels, affecting their transparency. When the polarisation angles align, the panels become more transparent, allowing more light to pass through."

Now go back to what you built in ten minutes:

A sensor reading a number. That number controlling whether an LED is on or off.

The Dots and your breadboard project are not different in kind. They are only different in scale.

Every complex interactive installation — the ones that fill galleries, the ones that go viral on design websites, the ones that make people stand in front of them for minutes — is built from this same basic chain. Sensor. Signal. Response.

You do not need to know everything before you start. You need to start with the feeling you want to create — and build the simplest possible version of that feeling first.

If you want to learn more about translating feelings into components, here is the framework:

Step 1: Write one sentence describing what you want the viewer to feel.
"When someone walks by, I want them to feel like the space is watching them."

Step 2: Identify what triggers the change.
"When someone gets close" > proximity sensor.

Step 3: Identify the type of response.
"The space should react, not just turn on" > gradual response, not binary.

Step 4: Choose the component that matches.
Proximity + gradual response > PWM-controlled output.

That is the entire framework. Not a worksheet. Not a decision tree. Just this:

What do you want them to feel? What tells the system they are there? How should it respond?

If you can answer those three questions, you can build anything in this space.

S6: What to Build Next

If you want to keep it simple:

A proximity-triggered LED is complete. To extend it: make it fade instead of just turning on/off. Then make it change color based on distance (RGB LED). Then add a second sensor.

If you want to scale toward The Dots:

Try a servo motor that rotates as you approach. The principle is identical — proximity reading controls motor angle instead of LED brightness.

If you want to see what this looks like at full scale:

The Bubble Wall project on Hackster (389 saves) documents a maker who built an interactive inflatable panel — a wall that produces bubbles in response to proximity. Read their project notes. Look at the photos. See how a simple idea at the component level becomes something that looks alive.

The feeling you are chasing — "it knows I'm here" — is not a technical achievement. It is a design achievement. The components are not the hard part. The hard part is deciding what feeling you want to create — and being willing to build toward it.

If this made you want to start building something, good. Go make the proximity LED first. Everything else comes from there.

Project References: