Arduino and ESP32 projects to 3D print, with parts lists, wiring and code

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_BME280.h>

Adafruit_SSD1306 oled(128, 64, &Wire, -1);   // 128 x 64 pixels, no reset pin
Adafruit_BME280 bme;

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);                          // SDA, SCL: the ESP32 defaults
  if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("OLED not found at 0x3C");
    while (true) delay(1000);
  }
  if (!bme.begin(0x76) && !bme.begin(0x77)) {  // breakouts use one or the other
    Serial.println("BME280 not found at 0x76 or 0x77");
    while (true) delay(1000);
  }
  oled.setTextColor(SSD1306_WHITE);
}

void loop() {
  float t = bme.readTemperature();             // degrees C
  float h = bme.readHumidity();                // % relative humidity
  float p = bme.readPressure() / 100.0F;       // Pa to hPa

  oled.clearDisplay();
  oled.setTextSize(2);
  oled.setCursor(0, 0);
  oled.printf("%.1f C\n", t);
  oled.setTextSize(1);
  oled.setCursor(0, 28);
  oled.printf("Humidity %.0f %%\n", h);
  oled.printf("Pressure %.0f hPa\n", p);
  oled.display();

  Serial.printf("%.2f C  %.1f %%  %.1f hPa\n", t, h, p);
  delay(2000);
}

Libraries: Adafruit BME280, Adafruit SSD1306 and Adafruit GFX from the Library Manager. Board: ESP32 Dev Module.

#include <FastLED.h>

#define DATA_PIN   16
#define NUM_LEDS   16
#define BUTTON_PIN 0        // the BOOT button on most ESP32 dev boards

CRGB leds[NUM_LEDS];
uint8_t mode = 0;           // 0 warm white, 1 rainbow, 2 candle
uint8_t hue = 0;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setMaxPowerInVoltsAndMilliamps(5, 450);   // stay inside what USB can give
  FastLED.setBrightness(160);
}

void loop() {
  static bool wasDown = false;
  bool down = digitalRead(BUTTON_PIN) == LOW;
  if (down && !wasDown) {
    mode = (mode + 1) % 3;
    delay(30);                                      // crude debounce
  }
  wasDown = down;

  if (mode == 0) {
    fill_solid(leds, NUM_LEDS, CRGB(255, 147, 41)); // warm white, like a candle bulb
  } else if (mode == 1) {
    fill_rainbow(leds, NUM_LEDS, hue++, 255 / NUM_LEDS);
  } else {
    for (int i = 0; i < NUM_LEDS; i++) {
      leds[i] = CRGB(255, 120, 20);
      leds[i].nscale8(random8(120, 255));           // each LED flickers on its own
    }
  }
  FastLED.show();
  delay(mode == 2 ? 60 : 20);
}

Library: FastLED. setMaxPowerInVoltsAndMilliamps dims everything just enough to stay under 450 mA.

const int TRIG = 9;
const int ECHO = 10;
const int LED = 6;
const int BUZZER = 5;       // a passive piezo buzzer: tone() sets the pitch

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  pinMode(LED, OUTPUT);
  Serial.begin(115200);
}

long readCm() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);
  delayMicroseconds(10);                             // a 10 us pulse starts a reading
  digitalWrite(TRIG, LOW);
  unsigned long us = pulseIn(ECHO, HIGH, 30000UL);   // give up after 30 ms (about 5 m)
  if (us == 0) return -1;                            // nothing in range
  return us / 58;                                    // out and back: about 58 us per cm
}

void loop() {
  long cm = readCm();
  Serial.println(cm);

  if (cm < 0 || cm > 150) {                          // far away: stay quiet
    noTone(BUZZER);
    digitalWrite(LED, LOW);
    delay(100);
    return;
  }
  if (cm < 20) {                                     // stop here
    tone(BUZZER, 2000);
    digitalWrite(LED, HIGH);
    delay(100);
    return;
  }
  int gap = map(cm, 20, 150, 60, 600);               // closer means faster beeps
  tone(BUZZER, 2000, 50);
  digitalWrite(LED, HIGH);
  delay(50);
  digitalWrite(LED, LOW);
  delay(gap);
}

No libraries needed. Board: Arduino UNO R4 Minima (install Arduino UNO R4 Boards in Boards Manager).

#include <WiFi.h>
#include <WebServer.h>

const char* WIFI_NAME = "your-network";       // 2.4 GHz only
const char* WIFI_PASS = "your-password";

const int SENSOR = 34;      // ADC1, so it keeps working while Wi-Fi is on
const int DRY = 3000;       // your reading in dry air
const int WET = 1300;       // your reading in a glass of water

WebServer server(80);

int moisture() {
  long sum = 0;
  for (int i = 0; i < 16; i++) { sum += analogRead(SENSOR); delay(5); }
  int raw = sum / 16;                                 // average out the noise
  return constrain(map(raw, DRY, WET, 0, 100), 0, 100);
}

void handleRoot() {
  int m = moisture();
  String html = "<!doctype html><meta name=viewport content='width=device-width'>"
                "<meta http-equiv=refresh content=10><title>Plant</title>"
                "<body style='font:24px system-ui;text-align:center;padding:40px'>"
                "<h1>" + String(m) + "%</h1><p>" +
                (m < 30 ? "Water me!" : "I'm fine, thanks.") + "</p>";
  server.send(200, "text/html", html);
}

void setup() {
  Serial.begin(115200);
  analogSetAttenuation(ADC_11db);                    // read the full 0 to ~3.1 V range
  WiFi.begin(WIFI_NAME, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print('.'); }
  Serial.printf("\nOpen http://%s\n", WiFi.localIP().toString().c_str());
  server.on("/", handleRoot);
  server.begin();
}

void loop() {
  server.handleClient();
  static unsigned long last = 0;
  if (millis() - last > 2000) {                      // raw readings, for calibrating
    last = millis();
    Serial.println(analogRead(SENSOR));
  }
}

Built-in libraries only. Replace DRY and WET with the readings the Serial Monitor shows for your sensor.

#include <ESP32Servo.h>
#include <esp_random.h>

const int SERVO_PIN = 13;
const int SWITCH_PIN = 14;  // switch to GND: LOW means "on"
const int REST = 10;        // arm tucked inside the box, in degrees
const int PUSH = 150;       // arm far enough to flip the switch: tune this

Servo arm;

void setup() {
  pinMode(SWITCH_PIN, INPUT_PULLUP);
  randomSeed(esp_random());                     // a different mood order every power-up
  arm.setPeriodHertz(50);
  arm.attach(SERVO_PIN, 500, 2400);             // SG90 pulse range in microseconds
  arm.write(REST);
}

void sweep(int from, int to, int stepDelay) {
  int dir = from < to ? 1 : -1;
  for (int a = from; a != to; a += dir) { arm.write(a); delay(stepDelay); }
  arm.write(to);
}

void loop() {
  if (digitalRead(SWITCH_PIN) == HIGH) return;  // switch is off: nothing to do

  switch (random(3)) {
    case 0:                                     // polite
      sweep(REST, PUSH, 4);
      break;
    case 1:                                     // sneaky: peek, wait, strike
      sweep(REST, 90, 12);
      delay(random(600, 1800));
      sweep(90, PUSH, 2);
      break;
    default:                                    // annoyed: twice, fast
      arm.write(PUSH); delay(250);
      arm.write(110);  delay(150);
      arm.write(PUSH); delay(250);
  }
  delay(200);
  sweep(PUSH, REST, 3);
}

Library: ESP32Servo from the Library Manager. Raise PUSH until the arm just flips the switch without straining.

#include "USB.h"
#include "USBHIDKeyboard.h"

USBHIDKeyboard Keyboard;

const int KEYS[3] = {4, 5, 6};     // each switch connects its pin to GND
bool wasDown[3] = {false, false, false};

void setup() {
  for (int i = 0; i < 3; i++) pinMode(KEYS[i], INPUT_PULLUP);
  Keyboard.begin();
  USB.begin();
}

void press(int i) {
  switch (i) {
    case 0:                                       // copy
      Keyboard.press(KEY_LEFT_CTRL); Keyboard.press('c');
      break;
    case 1:                                       // paste
      Keyboard.press(KEY_LEFT_CTRL); Keyboard.press('v');
      break;
    case 2:                                       // type a snippet
      Keyboard.print("Printed on my own macro pad!");
      return;
  }
  delay(20);
  Keyboard.releaseAll();
}

void loop() {
  for (int i = 0; i < 3; i++) {
    bool down = digitalRead(KEYS[i]) == LOW;
    if (down && !wasDown[i]) press(i);
    wasDown[i] = down;
  }
  delay(5);                                       // simple debounce
}

Board: ESP32S3 Dev Module, USB Mode: USB-OTG (TinyUSB). On a Mac use KEY_LEFT_GUI (Command) instead of KEY_LEFT_CTRL.