ESP32 Camera Viewer

#include <Arduino.h>
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>
#include "esp_camera.h"
#include <cstring>
#include <FS.h>
#include <SD_MMC.h>

// Separate from the camera, USB, flash, PSRAM and SD-card pins.
constexpr int TFT_SCK = 21, TFT_MOSI = 47, TFT_CS = 14;
constexpr int TFT_DC = 41, TFT_RST = 42;
Adafruit_ST7789 tft(&SPI, TFT_CS, TFT_DC, TFT_RST);
constexpr int VIEW_W = 180, VIEW_H = 135, VIEW_X = 30;
uint16_t previous[VIEW_H][VIEW_W];
uint16_t rowPixels[VIEW_W];
bool cameraReady = false, firstFrame = true;
uint32_t lastFrameTime = 0;
bool showingError = false;
constexpr int SHUTTER_PIN = 1;
bool sdReady = false, capturePending = false;
bool buttonRaw = HIGH, buttonStable = HIGH;
uint32_t buttonChanged = 0, statusUntil = 0, nextPhoto = 1;
constexpr int SELECT_PIN = 2, UP_PIN = 19, DOWN_PIN = 20;
bool gallery = false;
uint32_t galleryNumber = 0;
int navRaw = 0, navStable = 0;
uint32_t navChanged = 0;

bool mountCard() {
  // Freenove onboard slot: CLK39, CMD38, D0=40. 1-bit only.
  SD_MMC.setPins(39, 38, 40);
  sdReady = SD_MMC.begin("/sdcard", true, false); // NEVER format the card.
  if (sdReady && SD_MMC.cardType() == CARD_NONE) sdReady = false;
  if (!sdReady) SD_MMC.end();
  return sdReady;
}

void pollButton() {
  bool raw = digitalRead(SHUTTER_PIN);
  if (raw != buttonRaw) { buttonRaw = raw; buttonChanged = millis(); }
  if (raw != buttonStable && millis() - buttonChanged >= 35) {
    buttonStable = raw;
    if (raw == LOW) capturePending = true; // One photo per press, not hold.
  }
}

// Write a standard 24-bit BMP from the same RGB565 frame as the preview.
// Uses one small row buffer; no camera mode or PSRAM changes required.
bool savePhoto(camera_fb_t *fb, char *path, size_t pathSize) {
  if (!sdReady && !mountCard()) return false;
  if (!SD_MMC.exists("/photos") && !SD_MMC.mkdir("/photos")) return false;
  do {
    if (nextPhoto > 999999) return false;
    snprintf(path, pathSize, "/photos/IMG_%06lu.bmp", (unsigned long)nextPhoto++);
  } while (SD_MMC.exists(path));
  File file = SD_MMC.open(path, FILE_WRITE);
  if (!file) return false;
  const uint32_t stride = (fb->width * 3 + 3) & ~3U;
  const uint32_t imageSize = stride * fb->height;
  uint8_t header[54] = {};
  auto put16 = [&](int p, uint16_t v) {
    header[p] = v; header[p+1] = v >> 8;
  };
  auto put32 = [&](int p, uint32_t v) {
    for (int i = 0; i < 4; ++i) header[p+i] = v >> (8*i);
  };
  header[0] = 'B'; header[1] = 'M';
  put32(2, 54 + imageSize); put32(10, 54); put32(14, 40);
  put32(18, fb->width); put32(22, fb->height);
  put16(26, 1); put16(28, 24); put32(34, imageSize);
  uint8_t row[480] = {}; // Fixed 160-pixel capture width.
  bool ok = stride <= sizeof(row) && file.write(header, sizeof(header)) == sizeof(header);
  for (int y = fb->height - 1; ok && y >= 0; --y) {
    memset(row, 0, stride);
    for (unsigned x = 0; x < fb->width; ++x) {
      size_t p = (y * fb->width + x) * 2;
      uint16_t rgb = (uint16_t(fb->buf[p]) << 8) | fb->buf[p+1];
      uint8_t r = (rgb >> 11) & 31, g = (rgb >> 5) & 63, b = rgb & 31;
      row[x*3] = (b << 3) | (b >> 2);
      row[x*3+1] = (g << 2) | (g >> 4);
      row[x*3+2] = (r << 3) | (r >> 2);
    }
    ok = file.write(row, stride) == stride;
    yield();
  }
  file.flush();
  ok = ok && file.size() == 54 + imageSize;
  file.close();
  if (!ok) SD_MMC.remove(path); // Discard incomplete photos.
  return ok;
}

void message(const char *text, uint16_t color) {
  tft.fillScreen(ST77XX_BLACK);
  tft.setCursor(6, 45);
  tft.setTextColor(color);
  tft.setTextSize(1);
  tft.setTextWrap(true);
  tft.print(text);
}

// Three independent navigation buttons use internal pull-ups.
int navigationPress() {
  // Active-low buttons, one action per press after contact debounce.
  int key = digitalRead(SELECT_PIN) == LOW ? 3 :
            digitalRead(UP_PIN) == LOW ? 1 :
            digitalRead(DOWN_PIN) == LOW ? 2 : 0;
  if (key != navRaw) { navRaw = key; navChanged = millis(); }
  if (key != navStable && millis() - navChanged >= 45) {
    navStable = key;
    return key;
  }
  return 0;
}

bool showSavedPhoto(const char *path) {
  File file = SD_MMC.open(path, FILE_READ);
  uint8_t header[54];
  if (!file || file.read(header, sizeof(header)) != sizeof(header)) return false;
  auto u32 = [&](int p) -> uint32_t {
    return uint32_t(header[p]) | (uint32_t(header[p+1]) << 8) |
           (uint32_t(header[p+2]) << 16) | (uint32_t(header[p+3]) << 24);
  };
  // Only the uncompressed, bottom-up 160x120 BMP files this camera saves.
  if (header[0] != 'B' || header[1] != 'M' || u32(10) != 54 ||
      u32(14) != 40 || u32(18) != 160 || u32(22) != 120 ||
      header[26] != 1 || header[27] != 0 || header[28] != 24 ||
      header[29] != 0 || u32(30) != 0 || file.size() < 57654) return false;
  tft.fillScreen(ST77XX_BLACK);
  uint8_t bgr[480];
  for (int y = 0; y < 120; ++y) {
    if (!file.seek(54 + (119-y)*480) || file.read(bgr, sizeof(bgr)) != sizeof(bgr)) return false;
    for (int x = 0; x < 160; ++x) {
      rowPixels[x] = ((bgr[x*3+2] & 0xf8) << 8) |
                     ((bgr[x*3+1] & 0xfc) << 3) | (bgr[x*3] >> 3);
    }
    tft.startWrite();
    tft.setAddrWindow(40, y, 160, 1);
    tft.writePixels(rowPixels, 160);
    tft.endWrite();
    yield();
  }
  tft.setTextSize(1);
  tft.setTextColor(ST77XX_WHITE);
  tft.setCursor(4, 125);
  tft.print(strrchr(path, '/') + 1);
  tft.print("  Select: live");
  return true;
}

void browsePhotos(int direction, bool opening) {
  gallery = true;
  capturePending = false;
  statusUntil = 0;
  if (!sdReady && !mountCard()) {
    message("No SD card.\nSelect: live camera", ST77XX_RED);
    return;
  }
  File dir = SD_MMC.open("/photos");
  if (!dir || !dir.isDirectory()) {
    message("No saved photos.\nSelect: live camera", ST77XX_WHITE);
    return;
  }
  uint32_t smallest = 1000000, largest = 0, chosen = 0;
  for (File entry = dir.openNextFile(); entry; entry = dir.openNextFile()) {
    String name = entry.name();
    name = name.substring(name.lastIndexOf('/') + 1);
    if (!entry.isDirectory() && name.length() == 14 &&
        name.startsWith("IMG_") && name.endsWith(".bmp")) {
      bool digits = true;
      for (int i = 4; i < 10; ++i) if (name[i] < '0' || name[i] > '9') digits = false;
      uint32_t n = name.substring(4, 10).toInt();
      if (digits && n > 0) {
        if (n < smallest) smallest = n;
        if (n > largest) largest = n;
        if (direction > 0 && n > galleryNumber && (!chosen || n < chosen)) chosen = n;
        if (direction < 0 && n < galleryNumber && n > chosen) chosen = n;
      }
    }
    entry.close();
    yield();
  }
  dir.close();
  if (!largest) {
    message("No saved photos.\nSelect: live camera", ST77XX_WHITE);
    return;
  }
  if (opening) chosen = largest;
  else if (!chosen) chosen = direction > 0 ? smallest : largest;
  galleryNumber = chosen;
  char path[40];
  snprintf(path, sizeof(path), "/photos/IMG_%06lu.bmp", (unsigned long)chosen);
  if (!showSavedPhoto(path)) message("Cannot read this photo.\nUp/Down: another\nSelect: live camera", ST77XX_RED);
}

void setup() {
  pinMode(SHUTTER_PIN, INPUT_PULLUP);
  // GPIO19/20 are available only when native USB is not connected.
  pinMode(SELECT_PIN, INPUT_PULLUP);
  pinMode(UP_PIN, INPUT_PULLUP);
  pinMode(DOWN_PIN, INPUT_PULLUP);
  Serial.begin(115200);
  delay(300);
  // CS inactive before resetting the screen. BLK is powered from 3V3.
  pinMode(TFT_CS, OUTPUT);
  digitalWrite(TFT_CS, HIGH);
  SPI.begin(TFT_SCK, -1, TFT_MOSI, TFT_CS);
  tft.init(135, 240);
  tft.setRotation(1);
  tft.setSPISpeed(20000000);
  message("Starting camera...", ST77XX_WHITE);

  camera_config_t c = {};
  c.ledc_channel = LEDC_CHANNEL_0;
  c.ledc_timer = LEDC_TIMER_0;
  c.pin_d0 = 11; c.pin_d1 = 9; c.pin_d2 = 8; c.pin_d3 = 10;
  c.pin_d4 = 12; c.pin_d5 = 18; c.pin_d6 = 17; c.pin_d7 = 16;
  c.pin_xclk = 15; c.pin_pclk = 13;
  c.pin_vsync = 6; c.pin_href = 7;
  c.pin_sccb_sda = 4; c.pin_sccb_scl = 5;
  c.pin_pwdn = -1; c.pin_reset = -1;
  c.xclk_freq_hz = 20000000;
  c.pixel_format = PIXFORMAT_RGB565;
  c.frame_size = FRAMESIZE_QQVGA; // 160x120: modest memory, no PSRAM needed.
  c.jpeg_quality = 12; // Unused for RGB565.
  c.fb_count = 1;
  c.fb_location = CAMERA_FB_IN_DRAM;
  c.grab_mode = CAMERA_GRAB_WHEN_EMPTY;
  esp_err_t err = esp_camera_init(&c);
  if (err != ESP_OK) {
    Serial.printf("Camera initialization failed: 0x%x\n", unsigned(err));
    message("Camera not detected.\n\nUnplug USB; reseat ribbon.\nThen reconnect USB.", ST77XX_RED);
    return;
  }
  cameraReady = true;
  mountCard();
  Serial.println(sdReady ? "SD ready: press shutter on GPIO1." : "SD unavailable: insert FAT32 card with power off.");
  tft.fillScreen(ST77XX_BLACK);
  Serial.println("Camera ready: 160x120 RGB565, 180x135 preview. Button saves 160x120 BMP photos to /photos.");
}

void loop() {
  pollButton();
  int key = navigationPress();
  if (key == 3 && gallery) {
    gallery = false;
    capturePending = false;
    statusUntil = 0;
    showingError = false;
    firstFrame = true;
    tft.fillScreen(ST77XX_BLACK);
  } else if (key == 3) {
    browsePhotos(1, true);
  } else if (key == 1 || key == 2) {
    browsePhotos(key == 1 ? -1 : 1, !gallery);
  }
  if (gallery) {
    capturePending = false; // Shutter never saves while browsing.
    delay(1);
    return;
  }
  if (statusUntil) {
    if (int32_t(millis() - statusUntil) < 0) { delay(1); return; }
    statusUntil = 0;
    tft.fillScreen(ST77XX_BLACK);
    firstFrame = true;
  }
  if (!cameraReady) { delay(100); return; }
  if (millis() - lastFrameTime < 80) { delay(1); return; }
  lastFrameTime = millis();
  camera_fb_t *fb = esp_camera_fb_get();
  if (!fb) {
    if (!showingError) message("Camera frame failed.\nCheck power and ribbon.", ST77XX_RED);
    showingError = true;
    delay(200);
    return;
  }
  if (fb->format != PIXFORMAT_RGB565 || fb->len < fb->width * fb->height * 2) {
    esp_camera_fb_return(fb);
    delay(100);
    return;
  }
  if (showingError) {
    tft.fillScreen(ST77XX_BLACK);
    firstFrame = true;
    showingError = false;
  }
  // Preserve the full camera view, with black bars to either side.
  // RGB565 camera bytes arrive high byte first; convert for writePixels().
  for (int y = 0; y < VIEW_H; ++y) {
    unsigned sy = unsigned(y) * fb->height / VIEW_H;
    for (int x = 0; x < VIEW_W; ++x) {
      unsigned sx = unsigned(x) * fb->width / VIEW_W;
      size_t p = (sy * fb->width + sx) * 2;
      rowPixels[x] = (uint16_t(fb->buf[p]) << 8) | fb->buf[p + 1];
    }
    // Do not redraw an unchanged row; no repeated clearing or flicker.
    if (firstFrame || memcmp(previous[y], rowPixels, sizeof(rowPixels)) != 0) {
      tft.startWrite();
      tft.setAddrWindow(VIEW_X, y, VIEW_W, 1);
      tft.writePixels(rowPixels, VIEW_W);
      tft.endWrite();
      memcpy(previous[y], rowPixels, sizeof(rowPixels));
    }
  }
  firstFrame = false;
  if (capturePending) {
    capturePending = false;
    char path[40] = {};
    bool saved = savePhoto(fb, path, sizeof(path));
    esp_camera_fb_return(fb);
    if (saved) {
      char text[90];
      snprintf(text, sizeof(text), "Photo saved!\n\n%s", path);
      message(text, ST77XX_GREEN);
      Serial.printf("Saved %s\n", path);
    } else {
      message("Save failed.\nCheck FAT32 card / free space.\nPower off before removing card.", ST77XX_RED);
      Serial.println("Photo save failed; check card and free space.");
    }
    statusUntil = millis() + 1200;
    return;
  }
  esp_camera_fb_return(fb);
}