DEV Community

ONE WALL AI Publishing
ONE WALL AI Publishing

Posted on

How to Build an AI Wearable for Under $15 — Complete Step-by-Step Guide

#ai #hardware #tutorial #beginners

How to Build an AI Wearable for Under $15 — Complete Step-by-Step Guide

Imagine having a personal AI assistant on your wrist that can translate conversations in real time, answer health questions, or even help you write code—without needing a smartphone. This guide shows you how to build exactly that for under $15, using off‑the‑shelf parts and free software.

Why Build Your Own AI Wearable?

Commercial smartwatches lock you into their ecosystems. You can’t change the assistant’s behavior, add custom sensors, or see how the AI actually works. By building your own, you gain:

  • Full control over the AI’s prompts and responses.
  • Ability to attach any sensor—air quality, soil moisture, heart rate, etc.
  • Hands‑on learning about APIs, wireless communication, and embedded programming.
  • A functional prototype that costs less than a fancy coffee.

The core idea is simple: an ESP32 microcontroller handles input (buttons, microphone, sensors) and talks to Claude’s API over Wi‑Fi. The answer appears on a tiny OLED screen. Everything else is just wiring and code.

Bill of Materials (Under $15)

Part Approx. Cost Notes
ESP32‑S3 development board $4 Wi‑Fi + Bluetooth, plenty of GPIO
0.96″ OLED display (I2C) $2 128×64 pixels, crisp text
I2S microphone module $2 For voice input (optional for typing version)
3.7V Li‑Po battery + charger board $3 Makes it truly wearable
Jumper wires, breadboard $1 Prototyping without soldering
Total ~$12 Prices vary; look for kits on AliExpress, Amazon, or local electronics stores

All software tools are free: Arduino IDE, the Claude API (free tier available), and open‑source libraries.

Step 1: Set Up the Development Environment

  1. Install Arduino IDE (https://arduino.cc/en/software). Choose the version for your OS.
  2. Add ESP32 board support:
    • Open File → Preferences.
    • In “Additional Boards Manager URLs” add: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
    • Go to Tools → Board → Boards Manager, search for “esp32” and install the latest version.
  3. Install required libraries via Library Manager:
    • Adafruit SSD1306 – for the OLED.
    • ArduinoJson – to parse Claude’s JSON responses.
    • HTTPClient and WiFi – built‑in with ESP32 core.
    • (Optional) I2S library for microphone input.

Step 2: Wire the Components

Connect the parts as follows (refer to the pinout of your specific ESP32‑S3 board):

  • OLED Display

    • VCC → 3.3V
    • GND → GND
    • SCL → GPIO22 (or your board’s SCL)
    • SDA → GPIO21 (or your board’s SDA)

  • I2S Microphone (if using voice)

    • VCC → 3.3V
    • GND → GND
    • WS → GPIO25
    • SCK → GPIO26
    • SD → GPIO27

  • Battery

    • Connect to the charger board’s BAT+ and BAT‑ terminals.
    • The charger board’s OUT+ and OUT‑ go to the ESP32’s VBUS and GND (or use the built‑in Li‑Po connector if your board has one).

Double‑check all connections before powering up. A breadboard lets you test quickly; later you can solder or use a perfboard for durability.

Step 3: Obtain a Claude API Key

  1. Sign up at https://console.anthropic.com/.
  2. Create a new API key under Account → API Keys.
  3. Copy the key—you’ll need to paste it into the Arduino sketch.

Anthropic offers a free tier with generous monthly credits, perfect for prototyping.

Step 4: Write the Arduino Sketch

Below is a simplified sketch that lets you type a question via the Serial Monitor and see Claude’s answer on the OLED. For voice input, replace the Serial reading with an I2S‑to‑text pipeline (many examples exist online).

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// ----- USER SETTINGS -----
const char* ssid     = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* claudeKey = "YOUR_CLAUDE_API_KEY";
const char* claudeUrl = "https://api.anthropic.com/v1/messages";
// -------------------------

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET    -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22); // SDA, SCL – adjust if needed
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0,0);
  display.println(F("Connecting..."));
  display.display();

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected");
  display.clearDisplay();
  display.setCursor(0,0);
  display.println(F("WiFi OK"));
  display.display();
  delay(1000);
}

void loop() {
  if (Serial.available()) {
    String question = Serial.readStringUntil('\n');
    question.trim();
    if (question.length() == 0) return;

    // Show typing indicator
    display.clearDisplay();
    display.setCursor(0,0);
    display.print(F("Q: "));
    display.println(question);
    display.display();

    // Call Claude API
    if (WiFi.status() == WL_CONNECTED) {
      HTTPClient http;
      http.begin(claudeUrl);
      http.addHeader("Content-Type", "application/json");
      http.addHeader("X-API-Key", claudeKey);

      // Build JSON payload (Claude 3 message format)
      String payload = "{"
        "\"model\": \"claude-3-haiku-20240307\","
        "\"max_tokens\": 200,"
        "\"messages\": [{\"role\": \"user\", \"content\": \"" + question + "\"}]"
        "}";

      int httpResponseCode = http.POST(payload);
      String response = http.getString();
      http.end();

      if (httpResponseCode > 0) {
        // Parse JSON to extract Claude's reply
        DynamicJsonDocument doc(1024);
        DeserializationError error = deserializeJson(doc, response);
        if (!error) {
          String answer = doc["content"][0]["text"];
          // Display answer (scroll if needed)
          display.clearDisplay();
          display.setCursor(0,0);
          display.print(F("A: "));
          display.println(answer.substring(0, min(answer.length(), 60)));
          display.display();
        } else {
          display.clearDisplay();
          display.setCursor(0,0);
          display.println(F("JSON error"));
          display.display();
        }
      } else {
        display.clearDisplay();
        display.setCursor(0,0);
        display.print(F("HTTP error: "));
        display.println(httpResponseCode);
        display.display();
      }
    }
    delay(1500); // pause before next question
  }
}
Enter fullscreen mode Exit fullscreen mode

Explanation of key sections:

  • Wi‑Fi setup – connects the ESP32 to your network.
  • Display init – prepares the OLED for output.
  • Main loop – reads a question from Serial, sends it to Claude via HTTP POST, parses the JSON reply, and prints it on the screen.
  • Payload – uses the Claude 3 Haiku model (fast and inexpensive). Adjust max_tokens if you need longer answers.

Upload the sketch via Tools → Port (select your ESP32 port) then click the Upload button.

Step 5: Test and Iterate

  1. Open the Serial Monitor (115200 baud).
  2. Type a question like “What is the capital of Taiwan?” and press Enter.
  3. Watch the OLED show the question, then Claude’s answer after a couple of seconds.
  4. If you see errors:
    • Verify Wi‑Fi credentials.
    • Check that the API key is correct and has remaining credits.
    • Ensure the OLED is wired to the correct I2C pins (some boards use different defaults).

Once typing works, you can replace the Serial input with voice:

  • Use an I2S microphone library to capture audio.
  • Send the raw audio to a speech‑to‑text service (Google’s Web Speech API, Whisper.cpp on a companion device, or run a tiny model on the ESP32‑S3’s neural cores if you’re comfortable with TensorFlow Lite Micro).
  • Forward the transcribed text to Claude as shown above.

Step 6: Make It Wearable

  • Secure the battery to the back of the ESP32 board with double‑sided tape or a 3D‑printed clip.
  • Enclose the stack in a small project box or a custom‑sized wristband (laser‑cut acrylic, silicone strap, or even a repurposed watch band).
  • Route the microphone to a small hole on the side for clear voice capture.
  • Add a tactile button (wired to a GPIO) to trigger listening or to wake the device from sleep.

Extending Your Wearable

The basic framework is a springboard for countless enhancements:

Idea How to Implement
Health monitoring Connect a MAX30102 pulse oximeter, send heart‑rate data to Claude for analysis (“My HR is 110, should I rest?”).
Environmental sensor Add an SHT31 (temp/humidity) or CCS811 (air quality) and ask Claude for advice (“Is it safe to jog outside?”).
Language tutor Set Claude’s system prompt to “You are a patient language teacher. Correct my sentences gently.”
Code companion Use Claude to debug snippets: paste error messages, get explanations and fixes.
Gesture control Wire an accelerometer (MPU6050) and map shakes or taps to commands (e.g., shake to repeat last answer).

Each addition only requires wiring the sensor and adding a few lines to read its data before calling Claude.

Safety and Best Practices

  • Power management – Use deep‑sleep mode between interactions to extend battery life (ESP32 can sleep for microamps and wake on timer or button press).
  • Data privacy – Your voice and questions travel to Anthropic’s servers. Review their privacy policy; avoid sharing sensitive personal data.
  • Firmware updates – Keep the Arduino ESP32 core and libraries updated for security patches.
  • Enclosure – Ensure the battery is protected from short circuits and moisture if you plan to wear it outdoors.

Why This Beats Buying a Smartwatch

  • Cost – Under $15 versus $200+ for a premium watch.
  • Transparency – You see every line of code, every API call.
  • Flexibility – Swap sensors, change the AI’s personality, or even point the device at a local LLM for offline use.
  • Educational value – You’ll learn embedded networking, JSON handling, and prompt engineering—skills that transfer to IoT, robotics, and AI product development.

Ready to Take the Next Step?

If you’ve enjoyed building this prototype and want a detailed, illustrated walk‑through—including parts lists with links, wiring diagrams, and advanced voice‑integration tutorials—grab the free companion guide:

免費下載： https://jacksonfire526.gumroad.com/l/cdliu?utm_source=devto&utm_medium=article&utm_campaign=wearables-seo

For the complete, step‑by‑step manual that covers every chapter from unboxing to polishing the final wearable (including 3D‑printable case designs and prompt‑engineering cheat sheets), check out the full guide:

完整指南： https://jacksonfire526.gumroad.com/l/pfamyl?utm_source=devto&utm_medium=article&utm_campaign=wearables-seo

Start building today—your AI-powered wrist is just a few wires and a few lines of code away. Happy hacking!

Top comments (0)