Smart scale

Smart Food Scale

A connected 5 kg kitchen scale that displays weight and nutrition locally and syncs stable measurements to a phone.

[!WARNING] Work in progress. The custom PCB, enclosure, and camera-free v1 design are under active development. Review hardware/schematic-review.md before fabricating or powering a board; the repository is not a production-ready hardware release.

Project status

The camera-free product baseline is documented in docs/v1-baseline.md. The current custom schematic has diverged from some early component choices in that document, so use the KiCad files and hardware/schematic-review.md when assessing the board as it exists today.

Gallery

Custom PCB in the enclosure	Early breadboard proof of concept

Engineering views

These images show the current work-in-progress electrical and mechanical design.

Electrical design

PCB layout	PCB model

Mechanical assembly

Legacy camera prototype (retained code)

┌──────────────┐  weight + JPEG   ┌─────────────┐  food name   ┌──────────────────┐
│  ESP32-S3    │ ───────────────▶ │   Backend   │ ───────────▶ │  Claude Vision    │
│  + camera    │   POST /identify │  (FastAPI)  │ ◀─────────── │  (claude-sonnet)  │
│  + load cell │                  │             │   macros     ┌──────────────────┐
│  + OLED      │ ◀── live weight  │             │ ───────────▶ │  Open Food Facts  │
└──────────────┘   POST /weight   └─────┬───────┘ ◀─────────── └──────────────────┘
                                        │  GET /weight, /identify, /log, /logs
                                        ▼
                                 ┌─────────────┐
                                 │  Expo app   │  live weight, scan, confirm, log
                                 │  (iOS)      │
                                 └─────────────┘

Pipeline: put food on the scale → press the button (or tap Scan in the app) → the backend identifies the food with Claude Vision → looks up macros on Open Food Facts → the app shows the top matches → you confirm one → the meal is logged.

Repository layout

/app         Expo / React Native app for the legacy prototype
/backend     FastAPI + SQLite API for the legacy prototype
/docs        Camera-free v1 requirements and implementation baseline
/enclosure   SolidWorks sources and printable STL files
/firmware    ESP-IDF firmware for the legacy ESP32-S3-CAM prototype
/hardware    KiCad schematic, PCB, libraries, review notes, and fabrication files
README.md    Project overview and status

Prerequisites

• Python 3.10+ (backend)
• Node.js 18+ and the Expo tooling via npx (app)
• ESP-IDF v5.x (firmware) — install guide
• An Anthropic API key (console.anthropic.com)
• An iPhone with Expo Go (or the iOS simulator — note the simulator has no camera, so use a physical device to exercise the in-app Scan button)

The backend, the ESP32, and the phone must all be on the same local network.

1. Backend (/backend)

FastAPI + SQLite (aiosqlite), httpx, and the Anthropic SDK.

cd backend

# Create and activate a virtual environment
python -m venv .venv
source .venv/bin/activate          # Windows: .venv\Scripts\activate

pip install -r requirements.txt

# Configure API keys
cp .env.example .env               # Windows: copy .env.example .env
#   then edit .env: set ANTHROPIC_API_KEY=sk-ant-... (required), and for the
#   best per-ingredient macros set USDA_FDC_API_KEY (free, instant signup).

# Run (0.0.0.0 so the ESP32 and phone can reach it)
uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

Find your computer's LAN IP (ipconfig on Windows, ipconfig getifaddr en0 on macOS) — you'll need it for the firmware and the app.

Endpoints

/identify sends the image to Claude Vision (claude-sonnet-4-6), which breaks the dish into edible components (a simple food yields one). The measured weight is split across components by the model's estimates, and each is priced with macros from USDA FoodData Central (primary — accurate for generic foods), falling back to Open Food Facts for items USDA lacks. The response lists every component (name, weight, per-100g macros, matched source) plus summed totals for the dish. Components with no database match return null macros.

2. Firmware (/firmware)

ESP-IDF project for the GOOUUU ESP32-S3-CAM (OV2640 camera). Uses the esp32-camera component, esp_http_client, a raw SSD1306 I2C driver, and a bit-banged HX711 driver (both included under components/).

Wiring

Load cell: 1 kg, calibration factor -330. PSRAM pins 35/36/37 are reserved.

Configure, build, flash

1. Copy firmware/main/config.local.example.h to firmware/main/config.local.h, then edit the local file:
   • WIFI_SSID, WIFI_PASSWORD
   • BACKEND_URL → http://<your-computer-ip>:8000
2. Build and flash:

cd firmware
idf.py set-target esp32s3
idf.py build
idf.py -p <PORT> flash monitor      # e.g. -p COM5  or  -p /dev/ttyUSB0

PSRAM note: sdkconfig.defaults is set for octal PSRAM (the N16R8 module). If your board has quad PSRAM, change CONFIG_SPIRAM_MODE_OCT to CONFIG_SPIRAM_MODE_QUAD.

Behavior

• On boot: connects to WiFi, then continuously shows the current weight (large, centered) on the OLED, updating every 200 ms. It tares on the first stable reading — keep the scale empty during "TARING".
• Every 500 ms it POSTs the weight to /weight so the app can poll it.
• Pressing the button captures a JPEG, POSTs it with the current weight to /identify, shows "SCANNING" during the request, then returns to the weight display. (The device screen only ever shows the weight — no food names or macros — per the design.)

3. App (/app)

Expo / React Native (iOS primary), React Navigation bottom tabs.

cd app
npm install
# If Expo reports version mismatches: npx expo install --fix

npx expo start

Then press i for the iOS simulator, or scan the QR code with Expo Go on your iPhone.

Set the backend URL in app/src/config.ts:

export const API_BASE_URL = 'http://192.168.1.50:8000'; // your computer's LAN IP

(Use http://localhost:8000 only for the iOS simulator on the same Mac as the backend.)

Screens

• Scale tab — polls GET /weight every 500 ms and shows the live weight. Scan takes a photo, POSTs it with the current weight to /identify, and opens the results.
• Results — the dish broken into components (each with its weight, macros, and matched source) plus a total card for the whole meal, and a Log this meal button → POST /log → back to the Scale tab.
• Log tab — all logged meals with full macros, plus today's running totals (calories, protein, carbs, fat) at the top.

Design note — where the photo comes from. The hardware pipeline has the scale capture the image (button → /identify). For a self-contained app that works without the hardware, the in-app Scan button captures with the phone camera and calls the same /identify endpoint. To instead surface a scale-initiated scan in the app, poll GET /identify/latest (the backend caches the most recent result).

End-to-end test (no hardware required)

1. Start the backend (uvicorn ...).
2. Start the app, set API_BASE_URL to your computer's IP, open it on your phone.
3. Tap Scan, photograph some food, pick a match, and check the Log tab.

To simulate the scale's weight feed without hardware:

curl -X POST http://localhost:8000/weight \
  -H "Content-Type: application/json" -d '{"weight_g": 152.0}'

The Scale tab will show 152 g.