DEV Community: Arduino ESP32 Raspberry Pi Tutorials

ESP32 - LED Matrix via Web

Arduino ESP32 Raspberry Pi Tutorials — Thu, 22 Oct 2026 10:30:59 +0000

This build turns an ESP32 into a web-controlled signboard. You type text into a web page, it travels over WebSocket to the ESP32, and the ESP32 scrolls it across an FC-16 LED matrix. It's a neat way to see how a browser, a web server running on a microcontroller, and a physical display can talk to each other in real time.

The full tutorial, with every detail and the line-by-line code explanation, is on our site: ESP32 - LED Matrix via Web

What you need

Wiring

The FC-16 LED matrix connects to the ESP32 over a few data lines, with its CS (chip select) pin going to GPIO21 as set by CS_PIN in the sketch. If you're not sure how to power the ESP32 and the matrix together, it's worth checking a dedicated guide on powering ESP32 and displays before wiring things up, since a matrix made of multiple LED blocks can draw more current than the ESP32's own pins can supply.

How it works

The ESP32 runs two things at once: a web server that serves a page to your browser, and a WebSocket server that keeps a live connection open. When you type text on the page and send it, the message travels over the WebSocket to the ESP32 instead of as a regular HTTP request, which keeps things fast and responsive. On the ESP32 side, the MD_Parola library takes that text and scrolls it across the LED matrix, while the ESP32 sends a short confirmation message back to the browser over the same WebSocket connection.

Code

The sketch is split into two files: an .ino file with the ESP32 logic, and an index.h file holding the webpage's HTML, CSS and JavaScript. The .ino file sets up the web server and WebSocket server using the DIYables_ESP32_WebServer library, initializes the LED matrix with MD_Parola, and defines handlers for when a WebSocket connection opens, receives a message, or closes. The message handler clears the display and scrolls the incoming text with displayScroll(), then broadcasts a reply to connected clients.

esp32-led-matrix-via-web.ino

/*
 * This ESP32 code is created by esp32io.com
 *
 * This ESP32 code is released in the public domain
 *
 * For more detail (instruction and wiring diagram), visit https://esp32io.com/tutorials/esp32-led-matrix-via-web
 */

#include <DIYables_ESP32_WebServer.h>
#include "index.h"

#include <MD_Parola.h>
#include <MD_MAX72xx.h>

#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4  // 4 blocks
#define CS_PIN 21      // ESP32 pin GPIO21

// WiFi credentials
const char WIFI_SSID[] = "YOUR_WIFI_SSID";
const char WIFI_PASSWORD[] = "YOUR_WIFI_PASSWORD";

// Create web server instance
DIYables_ESP32_WebServer server;
DIYables_ESP32_WebSocket* webSocket;

// create an instance of the MD_Parola class
MD_Parola ledMatrix = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);


// Web Page handlers
void handleHome(WiFiClient& client, const String& method, const String& request, const QueryParams& params, const String& jsonData) {
  server.sendResponse(client, HTML_CONTENT);
}

// WebSocket event handlers
void onWebSocketOpen(net::WebSocket& ws) {
  Serial.println("New WebSocket connection");
  // Send welcome message
  const char welcome[] = "Connected to ESP32 WebSocket Server!";
}

void onWebSocketMessage(net::WebSocket& ws, const net::WebSocket::DataType dataType, const char* message, uint16_t length) {

  Serial.print("WebSocket Received (");
  Serial.print(length);
  Serial.print(" bytes): ");
  Serial.println(message);

  ledMatrix.displayClear();  // clear led matrix display
  ledMatrix.displayScroll(message, PA_CENTER, PA_SCROLL_LEFT, 100);

  // Broadcast response to all connected clients using the library
  if (webSocket != nullptr) {
    String response = "Displayed: " + String(message) + "on LED Matrix";
    webSocket->broadcastTXT(response);

    Serial.print("WebSocket sent (");
    Serial.print(response.length());
    Serial.print(" bytes): ");
    Serial.println(response);
  }
}

void onWebSocketClose(net::WebSocket& ws, const net::WebSocket::CloseCode code, const char* reason, uint16_t length) {
  Serial.println("WebSocket client disconnected");
}

void setup() {
  Serial.begin(9600);
  delay(1000);

  Serial.println("ESP32 Web Server and WebSocket Server");

  ledMatrix.begin();           // initialize the object
  ledMatrix.setIntensity(15);  // set the brightness of the LED matrix display (from 0 to 15)
  ledMatrix.displayClear();    // clear led matrix display

  ledMatrix.displayScroll("esp32io.com", PA_CENTER, PA_SCROLL_LEFT, 100);


  // Configure web server routes
  server.addRoute("/", handleHome);

  // Start web server with WiFi connection
  server.begin(WIFI_SSID, WIFI_PASSWORD);

  // Enable WebSocket functionality
  webSocket = server.enableWebSocket(81);

  if (webSocket != nullptr) {
    // Set up WebSocket event handlers
    webSocket->onOpen(onWebSocketOpen);
    webSocket->onMessage(onWebSocketMessage);
    webSocket->onClose(onWebSocketClose);
  } else {
    Serial.println("Failed to start WebSocket server");
  }
}

void loop() {
  // Then handle HTTP requests
  server.handleClient();

  // Handle WebSocket
  server.handleWebSocket();

  if (ledMatrix.displayAnimate()) {
    ledMatrix.displayReset();
  }
}

Things that go wrong

Before uploading, replace the placeholder WIFI_SSID and WIFI_PASSWORD values with your actual network credentials, otherwise the ESP32 never gets online. Make sure you've installed both the DIYables ESP32 WebServer library and MD_Parola through the Arduino IDE Library Manager, and that you've selected the correct ESP32 board and COM port, since a mismatched board selection is a common reason uploads fail silently.

Full tutorial

The complete tutorial - wiring diagram, code explanation and troubleshooting - is here: https://esp32io.com/tutorials/esp32-led-matrix-via-web

ESP32 C3 Super Mini - Switch

Arduino ESP32 Raspberry Pi Tutorials — Thu, 22 Oct 2026 04:00:47 +0000

An ON/OFF switch, also called a toggle switch, flips between two stable states each time you press it and stays there until you press it again - unlike a button, which only reports ON while you hold it down. This tutorial wires a two-pin ON/OFF switch to the ESP32 C3 Super Mini and reads its state in code, a pattern you'll reuse for lamp switches, mode selectors, or any on/off control in a project.

It also shows the debouncing trick that keeps switch-reading code short and reliable.

The full tutorial, with every detail and the line-by-line code explanation, is on our site: ESP32 C3 Super Mini - Switch

What you need

Wiring

Connect one pin of the switch to GPIO7 and the other pin to GND - the two pins have no polarity, so it doesn't matter which goes where. Stick to 3.3V logic; never feed 5V into any GPIO pin on the ESP32 C3 Super Mini. Avoid GPIO8 and GPIO9, since those are boot strapping pins used during startup. For a sturdier connection, solder the wires to the switch pins and cover the joints with heat shrink tubing.

How it works

The ESP32 C3 Super Mini has an internal pull-up resistor you can enable in software, so you don't need an external resistor - this tutorial relies on that built-in pull-up. With it enabled, the pin reads HIGH when the switch is open and LOW when it's closed. Because the switch is latching, each press flips the state and it holds there until you press it again, unlike a momentary button that only stays active while held.

Code

The sketch uses the ezButton library, which handles debouncing - filtering the brief electrical noise a mechanical contact produces when it opens or closes - and turns on the internal pull-up resistor for you. It reads the switch on GPIO7 with a 50 ms debounce filter, prints OFF -> ON or ON -> OFF whenever the state changes, and prints the current state as ON or OFF on every loop through the Serial Monitor.

esp32-c3-super-mini-switch.ino

/*
 * This ESP32 C3 Super Mini code was developed by newbiely.com
 *
 * This ESP32 C3 Super Mini code is made available for public use without any restriction
 *
 * For comprehensive instructions and wiring diagrams, please visit:
 * https://newbiely.com/tutorials/esp32-c3/esp32-c3-super-mini-switch
 */

#include <ezButton.h>

ezButton onOffSwitch(7);  // create ezButton object that attach to the ESP32 C3 SuperMini pin GPIO7

void setup() {
  Serial.begin(115200);
  onOffSwitch.setDebounceTime(50); // set debounce time to 50 milliseconds
}

void loop() {
  onOffSwitch.loop(); // MUST call the loop() function first

  if (onOffSwitch.isPressed())
    Serial.println("The switch: OFF -> ON");

  if (onOffSwitch.isReleased())
    Serial.println("The switch: ON -> OFF");

  int state = onOffSwitch.getState();
  if (state == HIGH)
    Serial.println("The switch: OFF");
  else
    Serial.println("The switch: ON");
}

Full tutorial

The complete tutorial - wiring diagram, code explanation and troubleshooting - is here: https://newbiely.com/tutorials/esp32-c3/esp32-c3-super-mini-switch

Arduino Mega - Piezo Buzzer

Arduino ESP32 Raspberry Pi Tutorials — Wed, 21 Oct 2026 10:31:05 +0000

A piezo buzzer is one of the cheapest ways to give an Arduino Mega a voice. It turns electrical signals into sound, so you can add beeps, alarms, or melodies to a project without needing a speaker, amplifier, or audio circuit. This guide covers the two main types of buzzer, how they're wired to the Mega, and how the code turns a pin into a sound source.

The full tutorial, with every detail and the line-by-line code explanation, is on our site: Arduino Mega - Piezo Buzzer

What you need

Wiring

A piezo buzzer has two terminals: a negative/ground pin and a positive/signal pin. The negative pin goes to the Arduino Mega's GND, and the positive pin connects to a digital output pin, such as pin 2 or 4. On wired buzzers the black or shorter wire is usually ground and the red or longer wire is signal; on PCB-mounted modules these are marked with - and +. For buzzers in the 3-5V range you can drive them directly from an Arduino digital pin with no extra driver circuitry needed.

How it works

Buzzers split into active and passive types. An active buzzer has its own internal oscillator, so applying a steady HIGH signal makes it produce a fixed tone (typically 2-4 kHz) automatically, just like turning on an LED - no frequency control needed. A passive buzzer has no oscillator; it stays silent under a plain digitalWrite(HIGH) and needs an alternating signal to vibrate the piezo element and produce sound. Piezo buzzers themselves use a ceramic crystal that flexes when voltage is applied, giving a wide frequency range, very low current draw, and no moving parts to wear out.

Code

For an active buzzer, the code is just digital on/off control: digitalWrite(buzzerPin, HIGH) starts a continuous tone and digitalWrite(buzzerPin, LOW) silences it. Because the tone's pitch is fixed by the buzzer's internal oscillator, you shape the sound by timing the pulses instead, for example looping short HIGH/LOW delays to produce a sequence of beeps rather than one long tone.

arduino-mega-piezo-buzzer.ino

// Simple continuous beep
digitalWrite(buzzerPin, HIGH);  // Turn on
delay(1000);                    // Beep for 1 second
digitalWrite(buzzerPin, LOW);   // Turn off

// Beep pattern example
for (int i = 0; i < 3; i++) {   // Three short beeps
  digitalWrite(buzzerPin, HIGH);
  delay(100);
  digitalWrite(buzzerPin, LOW);
  delay(100);
}

Full tutorial

The complete tutorial - wiring diagram, code explanation and troubleshooting - is here: https://newbiely.com/tutorials/arduino-mega/arduino-mega-piezo-buzzer

ESP8266 - Rotary Encoder

Arduino ESP32 Raspberry Pi Tutorials — Wed, 21 Oct 2026 04:00:52 +0000

A rotary encoder is the clicky knob you find on volume dials and 3D printer menus: turn it and it reports how far and which way it moved, plus it usually has a built-in pushbutton. This tutorial wires one up to an ESP8266 and reads direction and click count over serial, a nice building block for menus, speed controls or servo positioning.

The full tutorial, with every detail and the line-by-line code explanation, is on our site: ESP8266 - Rotary Encoder

What you need

Wiring

The encoder module has four pins. CLK goes to D7, DT goes to D6, and SW (the pushbutton output) goes to D5. VCC connects to the ESP8266's 3.3V (or up to 5V) supply and GND to ground. SW is normally open and relies on a pull-up so it reads HIGH when the knob isn't pressed and LOW when it is.

How it works

Inside the encoder, a slotted disc connects two pins, A (CLK) and B (DT), to a shared ground pin as you turn the knob. Because A and B touch ground at slightly different times, their signals are 90 degrees out of phase, known as quadrature encoding. Turning clockwise makes A go LOW before B; counter-clockwise makes B go LOW before A. By watching what DT is doing at the moment CLK changes from LOW to HIGH, you can tell which direction the knob just turned.

Code

The sketch reads CLK_PIN on every loop and compares it to its previous state. On a LOW-to-HIGH transition it checks digitalRead() on DT_PIN: DT HIGH means counter-clockwise (decrease the counter), DT LOW means clockwise (increase it). The direction and running count print to Serial. The ezButton library handles the SW pin with built-in debouncing, calling button.isPressed() to report clicks. An interrupt-based version of the same logic avoids polling CLK on every loop, so the ESP8266 won't miss fast turns while busy doing other work.

esp8266-rotary-encoder.ino

/*
 * This ESP8266 NodeMCU code was developed by newbiely.com
 *
 * This ESP8266 NodeMCU code is made available for public use without any restriction
 *
 * For comprehensive instructions and wiring diagrams, please visit:
 * https://newbiely.com/tutorials/esp8266/esp8266-rotary-encoder
 */

#include <ezButton.h>  // The library to use for SW pin

#define CLK_PIN D7  // The ESP8266 pin D7 connected to the rotary encoder's CLK pin
#define DT_PIN D6   // The ESP8266 pin D6 connected to the rotary encoder's DT pin
#define SW_PIN D5   // The ESP8266 pin D5 connected to the rotary encoder's SW pin

#define DIRECTION_CW 0   // clockwise direction
#define DIRECTION_CCW 1  // counter-clockwise direction

int counter = 0;
int direction = DIRECTION_CW;
int CLK_state;
int prev_CLK_state;

ezButton button(SW_PIN);  // create ezButton object for pin 7;

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

  // Configure encoder pins as inputs
  pinMode(CLK_PIN, INPUT);
  pinMode(DT_PIN, INPUT);
  button.setDebounceTime(50);  // set debounce time to 50 milliseconds

  // read the initial state of the rotary encoder's CLK pin
  prev_CLK_state = digitalRead(CLK_PIN);
}

void loop() {
  button.loop();  // MUST call the loop() function first

  // read the current state of the rotary encoder's CLK pin
  CLK_state = digitalRead(CLK_PIN);

  // If the state of CLK is changed, then pulse occurred
  // React to only the rising edge (from LOW to HIGH) to avoid double count
  if (CLK_state != prev_CLK_state && CLK_state == HIGH) {
    // if the DT state is HIGH
    // The encoder is rotating in counter-clockwise direction => decrease the counter
    if (digitalRead(DT_PIN) == HIGH) {
      counter--;
      direction = DIRECTION_CCW;
    } else {
      // The encoder is rotating in clockwise direction => increase the counter
      counter++;
      direction = DIRECTION_CW;
    }

    Serial.print("Rotary Encoder:: direction: ");
    if (direction == DIRECTION_CW)
      Serial.print("CLOCKWISE");
    else
      Serial.print("ANTICLOCKWISE");

    Serial.print(" - count: ");
    Serial.println(counter);
  }

  // save last CLK state
  prev_CLK_state = CLK_state;

  if (button.isPressed()) {
    Serial.println("The button is pressed");
  }
}

Full tutorial

The complete tutorial - wiring diagram, code explanation and troubleshooting - is here: https://newbiely.com/tutorials/esp8266/esp8266-rotary-encoder

ESP32 MicroPython DRV8833 DC Motor Driver

Arduino ESP32 Raspberry Pi Tutorials — Tue, 20 Oct 2026 10:30:44 +0000

A GPIO pin on the ESP32 can't drive a DC motor directly - it only gives a few milliamps at 3.3 volts, and a motor needs hundreds of milliamps plus the ability to reverse current. The DRV8833 driver solves both problems with two built-in H-bridges, letting you run one or two brushed DC motors from MicroPython using nothing but machine.PWM.

This walks through wiring one motor, then two, so you end up with basic forward, reverse and turn control for something like a small robot car.

The full tutorial, with every detail and the line-by-line code explanation, is on our site: ESP32 MicroPython DRV8833 DC Motor Driver

What you need

Wiring

IN1 and IN2 go to two PWM-capable GPIOs on the ESP32 and drive motor A; IN3 and IN4 do the same for motor B. OUT1/OUT2 and OUT3/OUT4 connect to the motor wires. VCC takes motor power from an external supply (2.7V to 10.8V), such as a 5V adapter through a DC power jack, never from the ESP32's 3.3V or 5V pin.

GND from the supply, the DRV8833 and the ESP32 all need to tie together, otherwise the IN signals have no reference and the motor behaves strangely. Tie EEP (nSLEEP) to the ESP32's 3.3V so the driver stays awake. If a motor spins the wrong way, swap its two OUT wires - no code change needed.

How it works

The DRV8833 has no separate enable pin like the L298N - you send PWM straight into the IN pins to set speed. For channel A, driving IN1 with PWM while IN2 stays LOW spins the motor forward; swapping which pin gets PWM reverses it. Both IN pins LOW lets the motor coast to a stop, and both HIGH brakes it quickly.

In MicroPython, duty_u16() takes 0 to 65535, so 0 means LOW, 65535 means HIGH, and anything in between sets the speed. The chip's output MOSFETs have low resistance, so little power turns into heat and the motor gets nearly the full battery voltage.

Code

The one-motor script sets up GPIO27 and GPIO26 as 1 kHz PWM outputs with machine.PWM and wraps the logic in a motor_a(speed) function that takes -100 to 100, converts it to a duty value, and picks which IN pin gets PWM based on the sign. motor_a_brake() drives both pins HIGH. The main loop ramps the motor up in 20% steps, holds full speed, coasts, reverses at 60%, then brakes, printing each step to the Shell.

The two-motor version adds GPIO33 and GPIO32 for channel B, generalizes the logic into set_channel(), and layers on forward(), backward(), turn_left(), turn_right() and stop() helpers built around one DRIVE_SPEED value.

esp32-micropython-drv8833-dc-motor-driver.py

"""
This ESP32 MicroPython code was developed by newbiely.com
This ESP32 MicroPython code is made available for public use without any restriction
For comprehensive instructions and wiring diagrams, please visit:
https://newbiely.com/tutorials/esp32-micropython/esp32-micropython-drv8833-dc-motor-driver
"""

from machine import Pin, PWM
import time

# ESP32 pins connected to channel A of the DRV8833 module
IN1_PIN = 27  # ESP32 GPIO27 connected to the IN1 pin of the DRV8833
IN2_PIN = 26  # ESP32 GPIO26 connected to the IN2 pin of the DRV8833
PWM_FREQ = 1000  # 1 kHz PWM, the DRV8833 accepts up to 50 kHz

# Both IN pins use PWM, because the DRV8833 has no separate speed (enable) pin
in1 = PWM(Pin(IN1_PIN), freq=PWM_FREQ)
in2 = PWM(Pin(IN2_PIN), freq=PWM_FREQ)
in1.duty_u16(0)  # start with the motor stopped (coast)
in2.duty_u16(0)

FULL_DUTY = 65535  # duty_u16() range is 0 to 65535


def percent_to_duty(percent):
    return percent * FULL_DUTY // 100  # convert 0-100% to 0-65535


def motor_a(speed):
    # speed: -100 to 100 (%). Positive = forward, negative = reverse, 0 = coast
    speed = max(-100, min(100, speed))
    if speed > 0:
        in1.duty_u16(percent_to_duty(speed))  # PWM on IN1
        in2.duty_u16(0)                       # IN2 LOW
    elif speed < 0:
        in1.duty_u16(0)                       # IN1 LOW
        in2.duty_u16(percent_to_duty(-speed)) # PWM on IN2
    else:
        in1.duty_u16(0)  # IN1 LOW + IN2 LOW = coast (motor rolls to a stop)
        in2.duty_u16(0)


def motor_a_brake():
    in1.duty_u16(FULL_DUTY)  # IN1 HIGH + IN2 HIGH = brake (fast stop)
    in2.duty_u16(FULL_DUTY)


while True:
    # forward: raise the speed step by step
    print("Forward: speeding up")
    for speed in range(20, 101, 20):
        motor_a(speed)
        print("  speed = {}%".format(speed))
        time.sleep(0.5)

    print("Forward: full speed for 2 seconds")
    time.sleep(2)

    print("Coast: motor rolls to a stop")
    motor_a(0)
    time.sleep(2)

    print("Reverse: 60% speed for 2 seconds")
    motor_a(-60)
    time.sleep(2)

    print("Brake: fast stop")
    motor_a_brake()
    time.sleep(1)

    motor_a(0)  # release the brake before the next loop
    print("----")
    time.sleep(1)

Things that go wrong

Both IN pins for a channel must sit on PWM-capable GPIOs - almost all ESP32 output pins qualify, but check this first if a motor ignores commands. If nothing moves at all, check EEP: it has to be HIGH or the chip sleeps and ignores every input.

A motor spinning the wrong direction just needs its two OUT wires swapped. Two motors draw more current than one, so size the 5V adapter at 2A or more. Test with the wheels free to spin, since a stalled motor can pull far more current than a spinning one.

Full tutorial

The complete tutorial - wiring diagram, code explanation and troubleshooting - is here: https://newbiely.com/tutorials/esp32-micropython/esp32-micropython-drv8833-dc-motor-driver

Arduino MicroPython Potentiometer

Arduino ESP32 Raspberry Pi Tutorials — Tue, 20 Oct 2026 04:00:48 +0000

A potentiometer is the simplest way to get a variable input into your code - turn a knob, get a number. This tutorial walks through wiring one up to an Arduino Giga R1 WiFi and reading it with MicroPython, converting the raw ADC reading into a voltage you can print to the console.

The full tutorial, with every detail and the line-by-line code explanation, is on our site: Arduino MicroPython Potentiometer

What you need

Wiring

A potentiometer has three pins. The GND pin goes to the board's GND (0 volts), the VCC pin goes to 3.3 volts, and the output pin (the wiper) connects to one of the Arduino's analog input pins, in this case A0. The board reads whatever voltage shows up on that middle pin.

How it works

Inside the potentiometer, turning the shaft moves a wiper along a resistive track between the GND and VCC pins. At 0 degrees the output pin sits at GND, so you read 0 volts. At the maximum angle it sits at VCC, so you read the full 3.3 volts. Anywhere in between, the output voltage scales with the angle: angle times VCC divided by the maximum angle. The Arduino's analog-to-digital converter (ADC) turns that voltage into a number between 0 and 4095, which you can then map into an angle, a voltage, or any other range your application needs, like a volume or brightness level.

Code

The script sets up an ADC on pin A0 and loops forever. Arduino's read_u16() returns a 16-bit reading, so the code shifts it right by 4 bits to get back the 12-bit range (0 to 4095) matching the hardware. A small map_value() helper rescales that number into a 0 to 3.3 volt range, and the loop prints both the raw ADC value and the computed voltage once per second using time.sleep(1).

arduino-micropython-potentiometer.py

"""
This Arduino MicroPython script was developed by newbiely.com
This Arduino MicroPython script is made available for public use without any restriction
For comprehensive instructions and wiring diagrams, please visit:
https://newbiely.com/tutorials/arduino-micropython/arduino-micropython-potentiometer
"""

from machine import ADC, Pin
import time

# Define a function to map a value from one range to another
def map_value(x, in_min, in_max, out_min, out_max):
    return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min

# Initialize the analog pin for reading
adc = ADC(Pin('A0')) # The Arduino Giga WiFi pin A0 connected to the S pin of water sensor

# Infinite loop
while True:
    # Retrieve analog value from pin A0:
    adc_value = adc.read_u16() >> 4 # Read the 16-bit analog value from the sensor and convert back to 12-bit ADC
    # Convert the analog value to a voltage (0-3.3V range):
    voltage = map_value(adc_value, 0, 4095, 0, 3.3)

    # Output the analog value and corresponding voltage to the console:
    print("Analog: {}, Voltage: {:.2f}V".format(adc_value, voltage))

    # Wait for a second before repeating the loop:
    time.sleep(1)

Full tutorial

The complete tutorial - wiring diagram, code explanation and troubleshooting - is here: https://newbiely.com/tutorials/arduino-micropython/arduino-micropython-potentiometer

Raspberry Pi - ADC

Arduino ESP32 Raspberry Pi Tutorials — Mon, 19 Oct 2026 10:30:42 +0000

The Raspberry Pi has no analog input pins, so it can't read a potentiometer or a gas sensor directly - every GPIO pin only knows about HIGH and LOW. The fix is an external Analog-to-Digital Converter. This walks through wiring an ADS1115 module to a Pi and reading sensor values over I2C from Python.

The full tutorial, with every detail and the line-by-line code explanation, is on our site: Raspberry Pi - ADC

What you need

Raspberry Pi 5
ADS1115 ADC Module
Potentiometer
Breadboard
Jumper Wires
Screw Terminal Block Shield for Raspberry Pi
Raspberry Pi Prototyping Base Plate & Breadboard Kit
DIYables Sensor Kit (18 sensors/displays)
DIYables USB Type-A to Type-B Cable

Wiring

The ADS1115 is a 16-bit, 4-channel ADC that talks to the Pi over I2C, so it only needs a handful of connections for power and data plus one input pin per sensor. This tutorial wires up a potentiometer as the example analog source, but the same module and setup work for a light sensor, a water sensor, or a soil moisture sensor since they all just output a varying voltage between 0 and 3.3V.

Because the ADS1115 has four input channels, you can wire up to four analog sensors to one module at the same time and read them independently. If your breadboard wiring gets messy, a screw terminal block shield for the Pi makes the connections more secure and easier to manage.

How it works

The ADS1115 measures an analog voltage between 0 and 3.3V and converts it into a 16-bit digital number, giving you much finer resolution than a simple on/off reading. It communicates with the Raspberry Pi over I2C, a two-wire protocol that lets multiple devices share the same data lines, which is why the module needs so few connections.

Before any of this works, I2C has to be turned on in the Pi's configuration, since it's disabled by default.

Code

On the software side, the Adafruit_ADS1x15 library handles the I2C communication with the module. The script creates an ADS1115 object, reads the 16-bit value from the channel the sensor is wired to, and prints it out once a second in a loop, so you get a continuous stream of readings in the terminal as you turn the potentiometer or change the sensor's conditions.

raspberry-pi-adc.py

"""
This Raspberry Pi code was developed by newbiely.com
This Raspberry Pi code is made available for public use without any restriction
For comprehensive instructions and wiring diagrams, please visit:
https://newbiely.com/tutorials/raspberry-pi/raspberry-pi-adc
"""


import time
import Adafruit_ADS1x15

# Create an ADS1115 ADC object
adc = Adafruit_ADS1x15.ADS1115()

while True:
    analog_value = adc.read_adc(0, gain=1)  # Read from channel 0
    print(f"Analog Value: {analog_value}")
    time.sleep(1)

Things that go wrong

If you see no output or errors instead of readings, double check that I2C is actually enabled in raspi-config under Interfacing Options, and that you rebooted the Pi afterward for the change to take effect. Also confirm the Pi has internet access the first time you run the script, since the Adafruit_ADS1x15 library needs to be installed before it can be imported.

Full tutorial

The complete tutorial - wiring diagram, code explanation and troubleshooting - is here: https://newbiely.com/tutorials/raspberry-pi/raspberry-pi-adc

ESP32 S3 - Soil Moisture Sensor

Arduino ESP32 Raspberry Pi Tutorials — Mon, 19 Oct 2026 01:46:01 +0000

A capacitive soil moisture sensor lets your ESP32 S3 tell you when soil is dry and needs water, without the corrosion problems of the cheap resistive probes you often see bundled with starter kits. This walkthrough covers wiring the sensor, reading raw values over serial, and calibrating a threshold so your code can report WET or DRY instead of just numbers.

The full tutorial, with every detail and the line-by-line code explanation, is on our site: ESP32 S3 - Soil Moisture Sensor

What you need

Wiring

The sensor has three pins: GND, VCC, and AOUT. Connect GND to the ESP32 S3's GND, VCC to the 3.3V pin, and AOUT to GPIO6. The sensor runs happily on 3.3V, so there's no need for a level shifter or any extra components between it and the board.

Keep the circuit board part of the sensor, the bit with the electronics, above the soil or water line at all times. Only the probe itself should go into the soil.

How it works

Capacitive sensors measure moisture by sensing capacitance changes in the soil around the probe, rather than passing current between exposed metal contacts like resistive sensors do. That means nothing touches the soil electrically, so there's no corrosion over time.

The output on AOUT is inversely proportional to moisture: wetter soil gives a lower voltage, drier soil gives a higher voltage. The ESP32 S3 reads that voltage through its ADC, so lower readings mean wet soil and higher readings mean dry soil.

Code

The sketch sets GPIO6 as an analog input, configures the ADC attenuation to handle inputs up to about 3.3V, then reads the pin every 500 milliseconds with analogRead() and prints the value to the Serial Monitor at 115200 baud. Run this version first, before soil, to watch raw numbers and figure out your own thresholds.

Once you've calibrated, you swap in a version that compares the reading against a THRESHOLD constant and prints WET or DRY accordingly.

esp32-s3-soil-moisture-sensor.ino

/*
 * This ESP32 S3 code was developed by newbiely.com
 *
 * This ESP32 S3 code is made available for public use without any restriction
 *
 * For comprehensive instructions and wiring diagrams, please visit:
 * https://newbiely.com/tutorials/esp32-s3/esp32-s3-soil-moisture-sensor
 */

#define AOUT_PIN 6 // The ESP32 S3 pin GPIO6 that connects to AOUT pin of moisture sensor

void setup() {
  Serial.begin(115200);
  // set the ADC attenuation to 11 dB (up to ~3.3V input)
  analogSetAttenuation(ADC_11db);
}

void loop() {
  int value = analogRead(AOUT_PIN); // read the analog value from sensor

  Serial.print("Moisture value: ");
  Serial.println(value);

  delay(500);
}

Things that go wrong

If your readings seem inconsistent regardless of sensor version, you may have a low-quality unit; the TLC555I-based capacitive sensor is the one confirmed to behave reliably. If you're testing in liquid rather than soil, use salt water, since pure water barely conducts and won't change the reading.

Thresholds also aren't universal: typical dry readings land around 2200–2500 and wet readings around 1200–1500, but your exact numbers depend on soil type, salinity, and probe depth, so recalibrate for your actual soil rather than reusing someone else's threshold.

Full tutorial

The complete tutorial - wiring diagram, code explanation and troubleshooting - is here: https://newbiely.com/tutorials/esp32-s3/esp32-s3-soil-moisture-sensor

Raspberry Pi Pico - Button

Arduino ESP32 Raspberry Pi Tutorials — Mon, 19 Oct 2026 01:31:55 +0000

A push button looks simple but trips up a lot of beginners because it has four pins instead of two, and because the way you wire it changes whether a press reads as HIGH or LOW in code. This walks through connecting a button to a Raspberry Pi Pico the easy way, using the Pico's internal pull-up resistor, and reading its state with MicroPython.

The full tutorial, with every detail and the line-by-line code explanation, is on our site: Raspberry Pi Pico - Button

What you need

Raspberry Pi Pico W
Raspberry Pi Pico
Micro USB Cable
Breadboard-mount Button with Cap
Breadboard-mount Button Kit
Panel-mount Button
Push Button Module
Breadboard
Jumper Wires
DIYables Sensor Kit (18 sensors/displays)

Wiring

A breadboard button actually has four legs, but they're internally paired, so only two of them are electrically distinct. Pick one pin from each pair: connect one to a Pico GPIO pin and the other to GND. With the internal pull-up enabled in code you don't need an external resistor at all.

If you're using a button module instead, it exposes three labeled pins: GND goes to ground, VCC goes to the Pico's 3.3V supply, and OUT goes to a digital input pin. That module's output idles LOW and goes HIGH when pressed.

How it works

Inside a push button are two contacts, call them pin A and pin B. While the button is untouched they're disconnected, so no current flows between them. Pressing the button physically bridges A and B together, completing the circuit.

What that means for the Pico's GPIO pin depends on how you wired it. With the internal pull-up setup used here, the pin reads HIGH when the button is untouched and drops to LOW the moment it's pressed, because pressing connects the pin to GND.

Code

The pin is configured with Pin(BUTTON_PIN, Pin.IN, Pin.PULL_UP), which tells the Pico to hold that pin HIGH internally until something pulls it LOW. From there the code just reads the pin's state to know whether the button is currently pressed.

You can extend this same reading logic to detect press and release as distinct events, rather than just polling the current state, which is useful if you want to react once per press instead of continuously while held.

raspberry-pi-pico-button.py

from machine import Pin
import time

BUTTON_PIN = 0 # The Raspberry Pi Pico pin connected to the button (GP0)

# Set up the button pin. The Pin.PULL_UP enables the internal pull-up resistor.
button = Pin(BUTTON_PIN, Pin.IN, Pin.PULL_UP)

while True:
    # Read the state of the button
    button_state = button.value()

    # Print the button's state
    print(button_state)

    # Wait for half a second before reading the button again
    time.sleep(0.5)

Things that go wrong

Mechanical contacts don't settle cleanly the instant they touch, they tend to bounce and register as several rapid presses before stabilizing. This is called chattering, and it mostly matters if your code is counting button presses, where a single press might get counted multiple times. For simple on/off state checks it's usually not worth worrying about.

Full tutorial

The complete tutorial - wiring diagram, code explanation and troubleshooting - is here: https://newbiely.com/tutorials/raspberry-pico/raspberry-pi-pico-button

Arduino Giga R1 WiFi LED Blink

Arduino ESP32 Raspberry Pi Tutorials — Mon, 19 Oct 2026 01:16:42 +0000

This tutorial walks through blinking an LED with the Arduino Giga R1 WiFi, using a digital output pin to switch it on and off. It is the simplest possible way to see GPIO control in action, and the same technique scales to turning any device on or off through a driver circuit.

The full tutorial, with every detail and the line-by-line code explanation, is on our site: Arduino Giga R1 WiFi LED Blink

What you need

Wiring

Connect the LED's cathode (-), the shorter lead with the flat edge on the case, to GND. Connect the anode (+), the longer lead, through a 220Ω resistor to a GPIO pin such as pin 9. The resistor limits current so the LED does not draw more than the Arduino's pins or the LED itself can handle. Getting the polarity backwards will not let current flow, so the LED just stays off rather than damaging anything at these voltages, but a module with a built-in resistor simplifies the wiring if you want to skip the standalone resistor.

How it works

An LED only lets current through in one direction, from anode to cathode, once the voltage across it is high enough to forward-bias its internal junction. Setting the GPIO pin HIGH applies 3.3V, which exceeds that threshold and lets current flow through the resistor and LED, lighting it. Setting the pin LOW drops the voltage to 0V, so there is no potential difference and the LED turns off. The resistor value is chosen so the current stays around a few milliamps, well within what the pin can safely source.

Code

The sketch sets the pin as an output with pinMode(pin, OUTPUT), then uses digitalWrite() to drive it HIGH or LOW with delays in between, which is what makes the LED blink. The same approach works for the board's built-in LED and for an external one; you just point the code at a different pin.

arduino-giga-r1-wifi-led-blink.ino

/*
 * This Arduino Giga R1 WiFi code was developed by newbiely.com
 *
 * This Arduino Giga R1 WiFi code is made available for public use without any restriction
 *
 * For comprehensive instructions and wiring diagrams, please visit:
 * https://newbiely.com/tutorials/arduino-giga/arduino-giga-r1-wifi-led-blink
 */

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, HIGH);  // turn the LED on (HIGH is the voltage level)
  delay(1000);                      // wait for a second
  digitalWrite(LED_BUILTIN, LOW);   // turn the LED off by making the voltage LOW
  delay(1000);                      // wait for a second
}

Full tutorial

The complete tutorial - wiring diagram, code explanation and troubleshooting - is here: https://newbiely.com/tutorials/arduino-giga/arduino-giga-r1-wifi-led-blink