Make A Diano Game Player

#include <Arduino.h>
#include "esp_camera.h"
#include <ESP32Servo.h>

// AI Thinker ESP32-CAM fixed OV2640 wiring.
#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27
#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22


// Forward declarations
bool obstacleInView(const camera_fb_t *frame);
void jump();
bool initCamera();

constexpr int SERVO_PIN = 16;
constexpr int REST_ANGLE = 25;
constexpr int PRESS_ANGLE = 72;
constexpr uint16_t PRESS_TIME_MS = 85;
constexpr uint16_t RECOVER_TIME_MS = 260;

// Frame is 160 x 120. Aim this scan region just ahead of the Dino at ground level.
constexpr int ROI_LEFT = 82;
constexpr int ROI_RIGHT = 116;
constexpr int ROI_TOP = 70;
constexpr int ROI_BOTTOM = 104;
constexpr uint8_t DARK_THRESHOLD = 80;
constexpr uint8_t OBSTACLE_PERCENT = 8;

Servo spaceServo;
uint32_t lastJumpAt = 0;

bool obstacleInView(const camera_fb_t *frame) {
  if (frame == nullptr || frame->format != PIXFORMAT_GRAYSCALE) return false;

  const int left = constrain(ROI_LEFT, 0, frame->width - 1);
  const int right = constrain(ROI_RIGHT, left + 1, frame->width);
  const int top = constrain(ROI_TOP, 0, frame->height - 1);
  const int bottom = constrain(ROI_BOTTOM, top + 1, frame->height);
  uint32_t darkPixels = 0;
  const uint32_t totalPixels = (right - left) * (bottom - top);

  for (int y = top; y < bottom; ++y) {
    const uint8_t *row = frame->buf + y * frame->width;
    for (int x = left; x < right; ++x) {
      if (row[x] < DARK_THRESHOLD) ++darkPixels;
    }
  }
  return darkPixels * 100UL >= totalPixels * OBSTACLE_PERCENT;
}

void jump() {
  spaceServo.write(PRESS_ANGLE);
  delay(PRESS_TIME_MS);
  spaceServo.write(REST_ANGLE);
}

bool initCamera() {
  camera_config_t config = {};
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sccb_sda = SIOD_GPIO_NUM;
  config.pin_sccb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_GRAYSCALE;
  config.frame_size = FRAMESIZE_QQVGA;
  config.jpeg_quality = 12;
  config.fb_count = 1;
  config.grab_mode = CAMERA_GRAB_LATEST;
  return esp_camera_init(&config) == ESP_OK;
}

void setup() {
  Serial.begin(115200);
  spaceServo.setPeriodHertz(50);
  spaceServo.attach(SERVO_PIN, 500, 2400);
  spaceServo.write(REST_ANGLE);

  if (!initCamera()) {
    Serial.println("Camera initialization failed; check that this is an AI Thinker ESP32-CAM.");
    while (true) delay(1000);
  }
  Serial.println("Dino player ready. Aim the camera at the game, then adjust the servo arm.");
}

void loop() {
  camera_fb_t *frame = esp_camera_fb_get();
  if (frame == nullptr) return;
  const bool obstacle = obstacleInView(frame);
  esp_camera_fb_return(frame);

  const uint32_t now = millis();
  if (obstacle && now - lastJumpAt >= RECOVER_TIME_MS) {
    jump();
    lastJumpAt = now;
  }
  delay(12);
}