ESP8266 Distance Measurement with Sharp IR Sensor Project

This project demonstrates how to interface a Sharp IR distance sensor with an ESP8266 microcontroller. The sensor reads distance values and displays the results on the Serial Monitor.

How It Works

A Sharp distance sensor such as the GP2Y0A21YK0F measures distance by triangulation, not by timing. An infrared LED emits a narrow beam; the reflected spot lands on a position-sensitive detector inside the package, and where it lands depends on how far away the object is. A closer object shifts the spot further across the detector.

This is a genuinely different principle from the obstacle sensors that merely report reflection, and it is why the Sharp part returns a usable distance rather than a yes/no. It is also why the output is highly nonlinear: voltage rises steeply as an object approaches, then flattens out with distance.

The GP2Y0A21YK0F is specified from 10 cm to 80 cm. Below 10 cm the curve folds back — the voltage falls again — so a reading of 2 V could mean either 10 cm or 4 cm. Any practical sketch must either guarantee nothing comes closer than 10 cm or combine the sensor with something that resolves the ambiguity.

The ESP8266 (NodeMCU) samples with a 10-bit ADC, so analogRead() returns 0–1023 across 3.3 V at the NodeMCU A0 header (the bare chip reads 0–1 V). A common approximation for converting the reading is distance ≈ 27.86 × V^-1.15, valid across the specified range.

Components Needed

ESP8266 (NodeMCU)
Sharp IR Distance Sensor
Jumper Wires
ESP8266 (NodeMCU)

Wiring to the ESP8266 (NodeMCU)

Connect the yellow output wire to A0, red to 5 V and black to ground. This sensor needs a 5 V supply and its output can approach 3.1 V at close range — near the 3.3 V ADC limit but generally safe. If you power it from 5 V on a 3.3 V board, add a divider for margin.

A 10 µF capacitor across VCC and GND at the sensor is specified by Sharp and is not optional in practice. The emitter draws current in sharp pulses, and without local decoupling those pulses appear as noise on the output.

Mount the sensor so its beam is unobstructed and perpendicular to the expected target. Angled surfaces deflect the reflection away from the detector and read as "far away" or as nothing at all.

Sensor wire	ESP8266 (NodeMCU) pin	Function
Yellow (Vo)	A0	Analog output, nonlinear with distance
Red (VCC)	5V	Supply — the sensor expects 4.5–5.5 V
Black (GND)	GND	Common ground

Build and Upload

Open the Arduino IDE with ESP8266 board support installed.

Install the necessary libraries (Wire and Adafruit_TCS34725).

Create a new sketch and paste the provided Arduino code.

Connect the ESP8266 to your computer, select the appropriate board and port from the Tools menu.

Upload the code to the ESP8266.

After uploading the code, open the Serial Monitor.

You should see the distance sensor readings (analog value, voltage, and calculated distance) printed to the Serial Monitor every half second.

Example Code

Converting the nonlinear output to centimetres, with median filtering. Upload it with the board set to ESP8266 (NodeMCU) and open the Serial Monitor at 115200 baud.

Converting the nonlinear output to centimetres, with median filtering

const int SENSOR_PIN = A0;
const float VREF = 3.3;
const int   ADC_MAX = 1023;

// Median of 5 rejects the occasional wild sample these sensors produce
int readMedian() {
  int s[5];
  for (int i = 0; i < 5; i++) { s[i] = analogRead(SENSOR_PIN); delay(5); }
  for (int i = 0; i < 4; i++)
    for (int j = i + 1; j < 5; j++)
      if (s[j] < s[i]) { int t = s[i]; s[i] = s[j]; s[j] = t; }
  return s[2];
}

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

void loop() {
  float volts = readMedian() * VREF / ADC_MAX;

  if (volts < 0.4) {                      // below ~0.4 V the target is out of range
    Serial.println("out of range (> 80 cm)");
  } else {
    float cm = 27.86 * pow(volts, -1.15); // Sharp GP2Y0A21 approximation
    if (cm < 10.0) {
      Serial.println("too close — reading ambiguous (< 10 cm)");
    } else {
      Serial.print("Distance: ");
      Serial.print(cm, 1);
      Serial.println(" cm");
    }
  }
  delay(200);
}

Applications

A sharp infrared distance sensor turns up in a wide range of projects. These are the uses where it is the right choice rather than a compromise:

Robot navigation where ultrasonic sensors struggle with soft or angled surfaces
Queue and people counting at fixed range
Liquid and material level sensing in hoppers and tanks
Automatic door and barrier triggers
Collision avoidance on small vehicles, paired with a wider-angle sensor

Working with the ESP8266 (NodeMCU)

The ESP8266 (NodeMCU) is built around the ESP8266 and runs on 3.3 V logic with roughly 80 KB usable of SRAM and 4 MB on most NodeMCU boards of program flash. These details change how this circuit is wired and what the sketch can do, so they are worth stating plainly before you build.

The ESP8266 is a 3.3 V part and is not 5 V tolerant — feeding a 5 V sensor output straight into a GPIO can damage the chip. Use a divider or level shifter.

There is only one ADC channel, so reading several analog sensors needs an external multiplexer such as a CD4051 or an ADS1115.

D3 (GPIO0), D4 (GPIO2) and D8 (GPIO15) are strapping pins sampled at boot; holding them at the wrong level stops the board starting.

Built-in WiFi means the same sketch can publish readings to a dashboard without extra hardware.

ESP8266 (NodeMCU) characteristic	Value	Why it matters here
Logic voltage	3.3 V	Sensor outputs above this level need a divider or level shifter
ADC resolution	10-bit (0–1023)	Sets how finely an analog reading can be resolved
Analog inputs	a single analog channel, A0	Determines how many analog sensors can share the board
PWM outputs	any GPIO via software PWM	Needed for brightness, speed and tone control
I²C pins	D2 (SDA, GPIO4) and D1 (SCL, GPIO5) by default	Fixed by hardware — wiring copied from another board may not match
Interrupt pins	any GPIO except D0 (GPIO16)	Required for counting fast or asynchronous events
Serial	one hardware UART plus a transmit-only second port	Monitor runs at 115200 baud by default

Troubleshooting

Most problems with this module fall into a handful of categories. Work through these before suspecting the part itself:

Distance readings fall as an object gets very close — you are in the fold-back region below 10 cm. Mechanically prevent anything approaching that close.
The output is noisy — the 10 µF decoupling capacitor is missing. Fit it directly at the sensor.
Dark objects read as further away — IR absorption reduces the returned signal. Expect reduced range on matte black.
Readings jump wildly — use the median filter shown rather than a plain average; these sensors emit occasional spurious samples that an average smears across good data.
The sketch compiles but the board resets or behaves erratically — a 5 V module output is being driven into a 3.3 V pin. Measure the signal before connecting it.
Readings differ from an Arduino tutorial for the same part — the 10-bit ADC returns 0–1023, not 0–1023, so any constant copied from an Uno example needs rescaling.

Taking It Further on the ESP8266 (NodeMCU)

Once the basic reading works, where you go next depends very much on which board you are using. These are the directions that suit the ESP8266 (NodeMCU) specifically:

The obvious extension on an ESP8266 is to stop printing to Serial and publish instead. A few lines using ESP8266WiFi and an HTTP client will push each reading to a dashboard such as ThingSpeak, or to an MQTT broker for home automation.

Running an onboard web server turns the board into its own display: serve a small HTML page that fetches the latest reading over AJAX, and any phone on the network becomes the instrument panel.

For battery operation, deep sleep is essential — the ESP8266 draws around 70 mA with WiFi active but under 20 µA asleep. Wire D0 (GPIO16) to RST so the board can wake itself, take a reading, publish and sleep again.

Notes and Practical Limits

Sharp sell several models with different ranges — the GP2Y0A41SK0F covers 4–30 cm and the GP2Y0A02YK0F covers 20–150 cm. The conversion constants differ for each, so check which part you have before trusting a formula found online.

Where ultrasonic and infrared both fit, they fail differently: ultrasonic struggles with soft fabric and angled surfaces, infrared struggles with dark and shiny ones. Projects that must be reliable often carry both.