AI Nutrition Kitchen Scale

#include <Arduino.h>
#include <M5Unified.h>
#include <WiFi.h>
#include <esp_now.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>
#include "secrets.h"

// Protocol shared by all three nodes. The XIAO scale node returns grams;
// the XIAO ESP32-S3 Sense returns an ordered set of JPEG chunks.
enum PacketType : uint8_t { WEIGH_REQUEST = 0xB1, WEIGHT_RESULT = 0xB2, CAPTURE_REQUEST = 0xA1, JPEG_CHUNK = 0xA2 };
struct __attribute__((packed)) WeightPacket { uint8_t type; float grams; };
struct __attribute__((packed)) JpegHeader { uint8_t type; uint16_t sequence; uint16_t total; uint16_t payloadLength; };
struct Nutrition { String name; float calories, protein, carbs, fat, fiber, sugar, sodium, potassium; };


// Forward declarations
void status(const char *line);
void onEspNowReceive(const esp_now_recv_info_t *, const uint8_t *data, int len);
bool sendAndWaitForWeight();
bool sendAndWaitForPhoto();
bool postToProxy(Nutrition &n);
void line(int y, const char *label, float value, const char *unit);
void drawResult(const Nutrition &n);
bool addPeer(const uint8_t *mac);

static constexpr size_t JPEG_CAPACITY = 140000;
static constexpr uint32_t SCALE_TIMEOUT_MS = 12000;
static constexpr uint32_t CAMERA_TIMEOUT_MS = 15000;
uint8_t *jpegData = nullptr;
volatile size_t jpegLength = 0;
volatile uint16_t expectedChunk = 0, expectedTotal = 0;
volatile bool jpegComplete = false, jpegInvalid = false, weightReceived = false;
volatile float measuredGrams = 0;

void status(const char *line) {
  M5.Display.fillScreen(TFT_WHITE);
  M5.Display.setTextColor(TFT_BLACK, TFT_WHITE);
  M5.Display.setTextSize(2); M5.Display.setCursor(15, 25); M5.Display.println("AI Kitchen Scale");
  M5.Display.setTextSize(1); M5.Display.setCursor(15, 75); M5.Display.println(line);
}

void onEspNowReceive(const esp_now_recv_info_t *, const uint8_t *data, int len) {
  if (len < 1) return;
  if (data[0] == WEIGHT_RESULT && len == (int)sizeof(WeightPacket)) {
    WeightPacket p; memcpy(&p, data, sizeof(p));
    measuredGrams = p.grams; weightReceived = isfinite(p.grams); return;
  }
  if (data[0] != JPEG_CHUNK || len < (int)sizeof(JpegHeader) || jpegInvalid || !jpegData) return;
  JpegHeader h; memcpy(&h, data, sizeof(h));
  if (h.payloadLength + sizeof(h) != (uint16_t)len || h.sequence != expectedChunk ||
      (expectedTotal && h.total != expectedTotal) || jpegLength + h.payloadLength > JPEG_CAPACITY) { jpegInvalid = true; return; }
  if (!expectedTotal) expectedTotal = h.total;
  memcpy(jpegData + jpegLength, data + sizeof(h), h.payloadLength);
  jpegLength += h.payloadLength; ++expectedChunk;
  if (expectedChunk == expectedTotal) jpegComplete = true;
}

bool sendAndWaitForWeight() {
  weightReceived = false;
  uint8_t request = WEIGH_REQUEST;
  if (esp_now_send(XIAO_SCALE_MAC, &request, 1) != ESP_OK) return false;
  uint32_t started = millis();
  while (!weightReceived && millis() - started < SCALE_TIMEOUT_MS) { M5.update(); delay(5); }
  return weightReceived;
}

bool sendAndWaitForPhoto() {
  jpegData = (uint8_t *)ps_malloc(JPEG_CAPACITY);
  if (!jpegData) jpegData = (uint8_t *)malloc(JPEG_CAPACITY);
  if (!jpegData) return false;
  jpegLength = 0; expectedChunk = 0; expectedTotal = 0; jpegComplete = false; jpegInvalid = false;
  uint8_t request = CAPTURE_REQUEST;
  if (esp_now_send(XIAO_CAMERA_MAC, &request, 1) != ESP_OK) return false;
  uint32_t started = millis();
  while (!jpegComplete && !jpegInvalid && millis() - started < CAMERA_TIMEOUT_MS) { M5.update(); delay(5); }
  return jpegComplete && !jpegInvalid && jpegLength > 100;
}

bool postToProxy(Nutrition &n) {
  String boundary = "----KitchenScaleBoundary";
  String prefix = "--" + boundary + "\r\nContent-Disposition: form-data; name=\"grams\"\r\n\r\n" + String(measuredGrams, 1) +
    "\r\n--" + boundary + "\r\nContent-Disposition: form-data; name=\"image\"; filename=\"food.jpg\"\r\nContent-Type: image/jpeg\r\n\r\n";
  String suffix = "\r\n--" + boundary + "--\r\n";
  size_t length = prefix.length() + jpegLength + suffix.length();
  uint8_t *body = (uint8_t *)ps_malloc(length);
  if (!body) body = (uint8_t *)malloc(length);
  if (!body) return false;
  memcpy(body, prefix.c_str(), prefix.length());
  memcpy(body + prefix.length(), jpegData, jpegLength);
  memcpy(body + prefix.length() + jpegLength, suffix.c_str(), suffix.length());
  HTTPClient http; http.begin(PROXY_URL);
  http.addHeader("Content-Type", "multipart/form-data; boundary=" + boundary);
  int responseCode = http.POST(body, length); free(body);
  if (responseCode != HTTP_CODE_OK) { http.end(); return false; }
  JsonDocument doc; DeserializationError err = deserializeJson(doc, http.getString()); http.end();
  if (err) return false;
  n.name = doc["food_name"] | doc["name"] | "Unknown food";
  JsonObject per100 = doc["per_100g"].as<JsonObject>();
  float multiplier = measuredGrams / 100.0f;
  auto nutrient = [&](const char *key) { return (per100[key] | doc[key] | 0.0f) * multiplier; };
  n.calories=nutrient("calories"); n.protein=nutrient("protein"); n.carbs=nutrient("carbs"); n.fat=nutrient("fat");
  n.fiber=nutrient("fiber"); n.sugar=nutrient("sugar"); n.sodium=nutrient("sodium"); n.potassium=nutrient("potassium");
  return true;
}

void line(int y, const char *label, float value, const char *unit) { M5.Display.setCursor(210, y); M5.Display.printf("%s: %.1f %s", label, value, unit); }
void drawResult(const Nutrition &n) {
  M5.Display.fillScreen(TFT_WHITE);
  M5.Display.drawJpg(jpegData, jpegLength, 10, 14, 190, 145);
  M5.Display.setTextColor(TFT_BLACK, TFT_WHITE); M5.Display.setTextSize(2); M5.Display.setCursor(210, 18); M5.Display.println(n.name);
  M5.Display.setTextSize(1); M5.Display.setCursor(210, 55); M5.Display.printf("Weight: %.1f g", measuredGrams);
  line(85,"Calories",n.calories,"kcal"); line(107,"Protein",n.protein,"g"); line(129,"Carbs",n.carbs,"g"); line(151,"Fat",n.fat,"g");
  line(173,"Fiber",n.fiber,"g"); line(195,"Sugar",n.sugar,"g"); line(217,"Sodium",n.sodium,"mg"); line(239,"Potassium",n.potassium,"mg");
  M5.Display.setCursor(10, 575); M5.Display.println("Press A for the next measurement.");
}

bool addPeer(const uint8_t *mac) {
  esp_now_peer_info_t peer = {}; memcpy(peer.peer_addr, mac, 6); peer.channel = 0; peer.encrypt = false;
  return esp_now_is_peer_exist(mac) || esp_now_add_peer(&peer) == ESP_OK;
}
void setup() {
  auto cfg = M5.config(); M5.begin(cfg); M5.Display.setRotation(0); status("Connecting to Wi-Fi...");
  WiFi.mode(WIFI_STA); WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  uint32_t started = millis(); while (WiFi.status() != WL_CONNECTED && millis() - started < 15000) delay(250);
  if (WiFi.status() != WL_CONNECTED) { status("Wi-Fi failed. Check secrets.h."); return; }
  if (esp_now_init() != ESP_OK || !addPeer(XIAO_SCALE_MAC) || !addPeer(XIAO_CAMERA_MAC)) { status("ESP-NOW peer setup failed."); return; }
  esp_now_register_recv_cb(onEspNowReceive);
  status("Ready. Empty the platter/container, then press A.");
}
void loop() {
  M5.update(); if (!M5.BtnA.wasPressed()) { delay(20); return; }
  status("Taring and measuring on the XIAO C6...");
  if (!sendAndWaitForWeight()) { status("Scale node failed. Check C6 power, MAC, and Wi-Fi channel."); return; }
  status("Capturing on the XIAO S3 Sense...");
  if (!sendAndWaitForPhoto()) { status("Camera failed. Check S3 Sense power, MAC, and Wi-Fi channel."); if (jpegData) { free(jpegData); jpegData=nullptr; } return; }
  status("Sending JPEG and grams to LAN proxy..."); Nutrition n = {};
  if (!postToProxy(n)) { status("Proxy failed. Check PROXY_URL and JSON response."); free(jpegData); jpegData=nullptr; return; }
  drawResult(n); free(jpegData); jpegData=nullptr;
}