Documentation

Wind Speed Sensor Anemometer with 0-5V Analog Output | ShillehTek Product Manual
Documentation / Wind Speed Sensor Anemometer with 0-5V Analog Output | ShillehTek Product Manual

Wind Speed Sensor Anemometer with 0-5V Analog Output | ShillehTek Product Manual

manualshillehtek

Overview

This wind speed sensor is a classic three-cup anemometer with a built-in signal conditioner: as wind spins the cups, the sensor converts the rotation into a clean 0-5V analog voltage that rises linearly with wind speed across its 0-30 m/s range. There is no bus protocol, no library, and no timing-critical pulse counting — one analog read and one multiplication give you the wind speed, which makes it one of the friendliest outdoor sensors you can add to a weather station.

The sealed housing and cup rotor are engineering plastic built for continuous outdoor exposure, with a shielded three-wire cable: brown is power, blue is the 0-5V signal, and black is ground. Note the supply requirement — the electronics inside want 7-24V DC (a 12V adapter or battery is the sweet spot), not the 5V or 3.3V from your microcontroller. The signal line, on the other hand, never exceeds 5V, so an Arduino reads it directly, while 3.3V boards like the ESP32 and Pico just need a two-resistor divider (the Raspberry Pi adds an external ADC, since it has no analog inputs).

Converting the voltage is one line of math: wind speed in m/s equals the output voltage times 6 (5V corresponds to 30 m/s). Cup anemometers need a light breeze of roughly 0.4-0.8 m/s to start turning, and this unit survives gusts far beyond its 30 m/s measurement ceiling. Typical builds include home weather stations, sailing and kite-field wind meters, high-wind alarms for awnings and drones, and long-term wind logging for solar or agricultural sites.

At a Glance

Output Signal
0 - 5V analog
Measurement Range
0 - 30 m/s
Supply Voltage
7 - 24V DC
Conversion
m/s = Volts x 6
Start Wind Speed
~0.4 - 0.8 m/s
Wires
Blue=Signal, Brown=Power, Black=GND

Specifications

Parameter Value
Sensor Type Three-cup rotary anemometer with analog conditioner
Output Signal 0 - 5V DC analog, linear with wind speed
Measurement Range 0 - 30 m/s (0 - 67 mph)
Conversion Formula Wind speed (m/s) = Vout x 6
Resolution ~0.1 m/s
Accuracy ±(0.3 + 0.03 x reading) m/s
Start Wind Speed 0.4 - 0.8 m/s
Supply Voltage 7 - 24V DC (12V recommended)
Survivable Wind Up to ~70 m/s structurally
Operating Temperature -40°C to +80°C
Cable 3-wire shielded: brown (power), blue (signal), black (ground)
Housing Weather-resistant engineering plastic, aviation connector

Pinout Diagram

The three wires do exactly what their labels say. Brown is the positive supply — connect it to a 7-24V DC source such as a 12V adapter. Black is ground, and it must be shared between the power supply and your microcontroller so the signal has a common reference. Blue is the analog output: 0V in still air rising linearly to 5V at 30 m/s. The blue wire sources a voltage, never draws meaningful current, so it connects straight to an ADC input (through a divider on 3.3V boards).

Wind speed sensor anemometer wiring diagram showing blue signal wire, brown power wire, and black ground wire

Wiring Guide

Arduino Wiring

The Arduino's 5V-tolerant analog inputs read the signal wire directly. The sensor itself is powered from a separate 12V supply (or the Arduino's VIN pin if the board runs from a 9-12V adapter), with grounds tied together.

Sensor Wire Connects To Details
Brown (Power) 12V DC supply + 7-24V range; VIN works on a 9-12V powered board
Black (GND) Supply - and Arduino GND Common ground is required
Blue (Signal) A0 0-5V, direct
Warning: Never connect the brown power wire to the Arduino's 5V pin — the sensor needs at least 7V to output accurate readings. Use a separate 12V adapter or battery, and always join its negative side to the Arduino's GND.
Tip: Give the cups a spin by hand after wiring — you should see the A0 voltage jump. It is the fastest sanity check before mounting the sensor on a mast.

ESP32 Wiring

ESP32 GPIO tops out at 3.3V, and the signal wire can reach 5V in strong wind — so the blue wire goes through a voltage divider (10k + 20k) that scales 0-5V down to 0-3.3V.

Sensor Wire Connects To Details
Brown (Power) 12V DC supply + 7-24V range
Black (GND) Supply - and ESP32 GND Common ground is required
Blue (Signal) GPIO 34 Via 10k/20k divider; ADC1 input-only pin
Warning: Do not wire the blue signal straight to an ESP32 pin. Build the divider: 10k resistor from the blue wire to GPIO 34, then 20k from GPIO 34 to GND. That scales 5V to 3.3V; the code multiplies readings by 1.5 to undo it.
Tip: Keep the analog line on an ADC1 pin (GPIO 32-39) — ADC2 pins stop working while Wi-Fi is active, which matters for a weather station that uploads readings.

Raspberry Pi Wiring

The Pi has no analog inputs, so an ADS1115 I2C ADC reads the sensor. Divide the signal down to the 0-3.3V range first, then feed it to the ADS1115 running from the Pi's 3.3V rail.

Wire / Pin Connects To Details
Brown (Power) 12V DC supply + 7-24V range
Black (GND) Supply - and Pi Pin 6 (GND) Common ground is required
Blue (Signal) ADS1115 A0 Via 10k/20k divider
ADS1115 VDD Pin 1 (3.3V)
ADS1115 GND Pin 6 (GND)
ADS1115 SDA Pin 3 (GPIO 2) I2C data
ADS1115 SCL Pin 5 (GPIO 3) I2C clock
Warning: With the ADS1115 powered at 3.3V, its inputs must stay below about 3.6V — that is why the divider comes first. 10k from the blue wire to the ADS1115 A0 input, 20k from A0 to GND.
Tip: Enable I2C with sudo raspi-config, then run i2cdetect -y 1 — the ADS1115 shows up at address 0x48 by default.

Raspberry Pi Pico Wiring

The Pico's built-in ADC reads the divided signal directly — same divider as the ESP32, landing on ADC0.

Sensor Wire Connects To Details
Brown (Power) 12V DC supply + 7-24V range
Black (GND) Supply - and Pico GND (pin 38) Common ground is required
Blue (Signal) GP26 (physical pin 31) Via 10k/20k divider; ADC0
Warning: Pico GPIO and ADC pins are 3.3V only. Use the 10k/20k divider on the blue wire (10k in series, 20k to ground) so a 30 m/s gust cannot push 5V into the chip.

Code Examples

Arduino

anemometer_arduino.ino
// Wind Speed Sensor (0-5V Anemometer) - Arduino Example
// Blue signal -> A0 (direct), Brown -> 12V supply, Black -> GND (shared)
// Wind speed (m/s) = Vout x 6   (5V = 30 m/s)

const int windPin = A0;
const int numSamples = 16;

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

void loop() {
  // Average several readings to steady the value in gusty air
  long total = 0;
  for (int i = 0; i < numSamples; i++) {
    total += analogRead(windPin);
    delay(5);
  }
  float raw = total / (float)numSamples;

  // Convert the 10-bit reading (0-1023) to volts (5V reference)
  float volts = raw * (5.0 / 1023.0);

  // Convert volts to wind speed
  float windMs = volts * 6.0;         // meters per second
  float windMph = windMs * 2.237;     // miles per hour

  Serial.print("Signal: ");
  Serial.print(volts, 2);
  Serial.print(" V | Wind: ");
  Serial.print(windMs, 1);
  Serial.print(" m/s (");
  Serial.print(windMph, 1);
  Serial.println(" mph)");

  delay(1000);
}

ESP32 (MicroPython)

anemometer_esp32.py
# Wind Speed Sensor (0-5V Anemometer) - ESP32 MicroPython Example
# Blue signal -> 10k/20k divider -> GPIO 34, Brown -> 12V, Black -> GND (shared)
# Divider scales 5V -> 3.33V, so multiply the measured volts by 1.5

from machine import ADC, Pin
import time

adc = ADC(Pin(34))        # ADC1 channel - keeps working with Wi-Fi on
adc.atten(ADC.ATTN_11DB)  # Full 0-3.3V input range

DIVIDER_RATIO = 1.5       # (10k + 20k) / 20k

while True:
    # Average several readings to steady the value in gusty air
    total_uv = 0
    for _ in range(16):
        total_uv += adc.read_uv()   # calibrated reading in microvolts
        time.sleep_ms(5)
    volts_at_pin = total_uv / 16 / 1_000_000

    # Undo the divider, then convert to wind speed
    signal_volts = volts_at_pin * DIVIDER_RATIO
    wind_ms = signal_volts * 6.0
    wind_mph = wind_ms * 2.237

    print("Signal: {:.2f} V | Wind: {:.1f} m/s ({:.1f} mph)".format(
        signal_volts, wind_ms, wind_mph))
    time.sleep(1)

Raspberry Pi (Python + ADS1115)

anemometer_rpi.py
#!/usr/bin/env python3
# Wind Speed Sensor (0-5V Anemometer) - Raspberry Pi + ADS1115 Example
# Blue signal -> 10k/20k divider -> ADS1115 A0, SDA/SCL -> GPIO 2/3
# Install: pip3 install adafruit-circuitpython-ads1x15

import time
import board
import busio
import adafruit_ads1x15.ads1115 as ADS
from adafruit_ads1x15.analog_in import AnalogIn

DIVIDER_RATIO = 1.5   # (10k + 20k) / 20k

i2c = busio.I2C(board.SCL, board.SDA)
ads = ADS.ADS1115(i2c)
ads.gain = 1          # +/-4.096V range covers the divided 0-3.33V signal
channel = AnalogIn(ads, ADS.P0)

try:
    while True:
        signal_volts = channel.voltage * DIVIDER_RATIO
        wind_ms = signal_volts * 6.0
        wind_mph = wind_ms * 2.237

        print("Signal: {:.2f} V | Wind: {:.1f} m/s ({:.1f} mph)".format(
            signal_volts, wind_ms, wind_mph))
        time.sleep(1)

except KeyboardInterrupt:
    print("Measurement stopped by user")

Raspberry Pi Pico (MicroPython)

anemometer_pico.py
# Wind Speed Sensor (0-5V Anemometer) - Pico MicroPython Example
# Blue signal -> 10k/20k divider -> GP26 (ADC0), Brown -> 12V, Black -> GND
# Divider scales 5V -> 3.33V, so multiply the measured volts by 1.5

from machine import ADC
import time

adc = ADC(26)                 # GP26 = ADC0
CONVERSION = 3.3 / 65535      # read_u16() spans 0-65535 across 0-3.3V
DIVIDER_RATIO = 1.5           # (10k + 20k) / 20k

while True:
    # Average several readings to steady the value in gusty air
    total = 0
    for _ in range(16):
        total += adc.read_u16()
        time.sleep_ms(5)
    volts_at_pin = (total / 16) * CONVERSION

    signal_volts = volts_at_pin * DIVIDER_RATIO
    wind_ms = signal_volts * 6.0
    wind_mph = wind_ms * 2.237

    print("Signal: {:.2f} V | Wind: {:.1f} m/s ({:.1f} mph)".format(
        signal_volts, wind_ms, wind_mph))
    time.sleep(1)

Frequently Asked Questions

Can I power this anemometer from my Arduino's 5V pin?
No — the internal conditioning circuit needs 7-24V DC on the brown wire, and at 5V the output is not reliable. A 12V wall adapter or battery is ideal. Connect its negative terminal to both the black wire and your board's GND so all three share one ground reference.
How do I convert the voltage into wind speed?
Multiply the signal voltage by 6 to get meters per second: the 0-5V range maps linearly onto 0-30 m/s. Multiply m/s by 2.237 for mph or by 3.6 for km/h. For example, 1.25V equals 7.5 m/s, about 17 mph — a fresh breeze.
Can I wire the signal directly to an ESP32, Pico, or Raspberry Pi?
Not directly. The signal can reach 5V in strong wind, and those boards' inputs are 3.3V only. Add a two-resistor divider (10k in series, 20k to ground) to scale the signal to 0-3.3V, then multiply readings by 1.5 in code. On the Raspberry Pi you also need an external ADC such as the ADS1115, since the Pi has no analog inputs at all.
Why does it read zero in a light breeze?
Cup anemometers have a mechanical starting threshold — this one needs roughly 0.4-0.8 m/s before the rotor overcomes bearing friction and begins to spin. Below that the output legitimately sits at 0V. If it reads zero in obvious wind, spin the cups by hand: a rising voltage means the sensor is fine and the mounting spot is just sheltered.
How accurate is it, and can I check the calibration?
Expect about ±(0.3 + 0.03 x reading) m/s — roughly ±0.6 m/s at a 10 m/s wind. A practical sanity check is comparing against a handheld anemometer or a nearby weather station during steady wind. For serious work, mount it well clear of roofs, walls, and trees, which distort wind far more than the sensor's own tolerance.
Is it safe to leave outside year-round?
Yes — the housing is weather-resistant engineering plastic rated for -40°C to +80°C, and the structure survives winds far beyond the 30 m/s measurement ceiling. Mount it vertically on a mast with open airflow, point the cable connector downward, and seal the connector with self-fusing tape if your site sees driving rain.
Do I need a library to read it?
No. It is a plain analog voltage, so analogRead() on Arduino and the machine module's ADC class in MicroPython are all you need. The only library situation is the Raspberry Pi, where the ADS1115 driver (adafruit-circuitpython-ads1x15) reads the external ADC over I2C.

Related Tutorials