ساخت دستگاه فروش خودکار (وندینگ) با آردوینو

/* Vending Machine - ESP32 (WiFi + Payment + Stepper + OLED + QR)
   - Requires: ArduinoJson, Adafruit_SSD1306, Adafruit_GFX, AccelStepper, qrcode (or qrcodegen)
   - Hardware assumptions: ESP32, SSD1306 128x64 I2C, stepper driver (STEP/DIR), IR sensor for product detection.
   - Note: Replace SERVER_URL and API_KEY placeholders with your backend info.
*/

#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#include <AccelStepper.h>

// QR code generator: include your QR library here.
// Example uses a simple qrcodegen library interface - adjust if your library differs.
#include "qrcodegen.h" // If using the qrcodegen library by Nayuki (rename appropriately)

//////////////////////
// Configuration
//////////////////////
const char* WIFI_SSID = "YOUR_WIFI_SSID";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";

const char* SERVER_BASE = "https://your-backend.example.com"; // بدون اسلش انتهایی
const char* API_CREATE_ORDER = "/create_order";
const char* API_ORDER_STATUS = "/order_status"; // expect GET ?order_id=...

const char* DEVICE_ID = "vending_esp32_01"; // شناسه دستگاه برای سرور

// Hardware pins
#define OLED_SDA 21
#define OLED_SCL 22
#define OLED_RST -1 // -1 اگر RST متصل نیست

#define STEPPER_STEP_PIN 26
#define STEPPER_DIR_PIN 27
#define STEPPER_ENABLE_PIN 14

#define IR_SENSOR_PIN 34 // ورودی آنالوگ/دیجیتال خواندنی (اینجا دیجیتال)
#define SELECT_BUTTON_PIN 32
#define LED_STATUS_PIN 13

// Stepper configuration
#define STEPS_PER_PRODUCT 200 // عدد مراحل لازم برای تحویل یک کالا - باید تنظیم شود
#define MAX_SPEED 1000
#define ACCEL 500

// OLED
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RST);

// Stepper
AccelStepper stepper(AccelStepper::DRIVER, STEPPER_STEP_PIN, STEPPER_DIR_PIN);

// Product definitions (نمونه ساده)
struct Product {
  const char* id;
  const char* name;
  int price; // تومان یا واحد مورد نظر
  int stepsToRelease; // میزان حرکت استپر برای آزادسازی این محصول
  int stock;
};

Product products[] = {
  {"A1", "شکلات", 8000, STEPS_PER_PRODUCT, 10},
  {"A2", "چیپس", 7000, STEPS_PER_PRODUCT, 10},
  {"A3", "آب", 5000, STEPS_PER_PRODUCT, 10},
};

const int productCount = sizeof(products)/sizeof(products[0]);

// Runtime state
String currentOrderId = "";
int selectedProductIndex = 0;
bool waitingForPayment = false;
unsigned long paymentRequestTime = 0;
const unsigned long PAYMENT_TIMEOUT_MS = 120000; // 2 دقیقه

//////////////////////
// Utility Functions
//////////////////////

void showMessage(const char* line1, const char* line2 = NULL, const char* line3 = NULL) {
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0,0);
  display.println(line1);
  if (line2) display.println(line2);
  if (line3) display.println(line3);
  display.display();
}

void showProductList() {
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0,0);
  for (int i=0;i<productCount;i++) {
    if (i == selectedProductIndex) display.print("> ");
    else display.print("  ");
    display.print(i+1);
    display.print(". ");
    display.print(products[i].name);
    display.print(" - ");
    display.print(products[i].price);
    display.println("ت");
  }
  display.display();
}

void setupStepper() {
  pinMode(STEPPER_ENABLE_PIN, OUTPUT);
  digitalWrite(STEPPER_ENABLE_PIN, HIGH); // disable initially (active low usually)
  stepper.setMaxSpeed(MAX_SPEED);
  stepper.setAcceleration(ACCEL);
}

void enableStepper(bool en) {
  digitalWrite(STEPPER_ENABLE_PIN, en ? LOW : HIGH); // depends on your driver; LOW = enabled for many
}

String httpPostCreateOrder(const char* productId, int price) {
  // Builds JSON: { device_id, product_id, price }
  // Sends POST to SERVER_BASE + API_CREATE_ORDER
  HTTPClient http;
  String url = String(SERVER_BASE) + String(API_CREATE_ORDER);
  http.begin(url);
  http.addHeader("Content-Type", "application/json");
  // Optional: add API key header
  // http.addHeader("Authorization", "Bearer YOUR_KEY");

  StaticJsonDocument<256> doc;
  doc["device_id"] = DEVICE_ID;
  doc["product_id"] = productId;
  doc["price"] = price;

  String payload;
  serializeJson(doc, payload);

  int httpCode = http.POST(payload);
  if (httpCode != 200) {
    Serial.printf("CreateOrder HTTP error: %d\n", httpCode);
    http.end();
    return "";
  }

  String resp = http.getString();
  http.end();

  // Parse response: expect { order_id: "...", payment_url: "..." }
  StaticJsonDocument<512> respDoc;
  DeserializationError err = deserializeJson(respDoc, resp);
  if (err) {
    Serial.println("JSON parse error on createOrder");
    return "";
  }

  const char* orderId = respDoc["order_id"] | "";
  const char* paymentUrl = respDoc["payment_url"] | "";

  if (strlen(orderId) == 0 || strlen(paymentUrl) == 0) {
    Serial.println("Invalid response from server createOrder");
    return "";
  }

  // Save order id in EEPROM or RAM; here just return paymentUrl but store orderId global
  currentOrderId = String(orderId);

  // For convenience, store the payment URL in a file or global; we'll return it
  return String(paymentUrl);
}

String httpGetOrderStatus(const char* orderId) {
  HTTPClient http;
  String url = String(SERVER_BASE) + String(API_ORDER_STATUS) + "?order_id=" + String(orderId);
  http.begin(url);
  int httpCode = http.GET();
  if (httpCode != 200) {
    Serial.printf("GetOrderStatus HTTP error: %d\n", httpCode);
    http.end();
    return "error";
  }
  String resp = http.getString();
  http.end();

  StaticJsonDocument<256> respDoc;
  DeserializationError err = deserializeJson(respDoc, resp);
  if (err) {
    Serial.println("JSON parse error on orderStatus");
    return "error";
  }
  const char* status = respDoc["status"] | "error";
  return String(status);
}

//////////////////////
// QR Display Helpers (using qrcodegen library by Nayuki as example)
//////////////////////

void drawQRCodeOnOLED(const String &text) {
  // adjust to the QR library you have. Here uses qrcodegen::QrCode
  using qrcodegen::QrCode;
  using qrcodegen::QrSegment;

  QrCode qr = QrCode::encodeText(text.c_str(), QrCode::Ecc::LOW);
  int size = qr.getSize(); // e.g., 21, 25, ... matrix size
  int scale = SCREEN_WIDTH / (size + 2); // leave margin
  if (scale <= 0) scale = 1;
  int margin = (SCREEN_WIDTH - size*scale) / 2;

  display.clearDisplay();
  // Draw QR
  for (int y = 0; y < size; y++) {
    for (int x = 0; x < size; x++) {
      bool module = qr.getModule(x, y); // black or white
      if (module) {
        int rx = margin + x*scale;
        int ry = margin + y*scale;
        display.fillRect(rx, ry, scale, scale, SSD1306_WHITE);
      }
    }
  }
  // Optional: print short URL below if fits
  display.display();
}

//////////////////////
// Product release + sensor
//////////////////////

bool waitForProductDrop(unsigned long timeoutMs) {
  unsigned long start = millis();
  while (millis() - start < timeoutMs) {
    int val = digitalRead(IR_SENSOR_PIN);
    // sensor logic: assume LOW when beam broken (product passed)
    if (val == LOW) {
      Serial.println("Product detected by IR sensor.");
      return true;
    }
    delay(50);
  }
  return false;
}

bool releaseProduct(int stepsToMove) {
  enableStepper(true);
  // rotate in appropriate direction
  stepper.moveTo(stepper.currentPosition() + stepsToMove);
  while (stepper.distanceToGo() != 0) {
    stepper.run();
  }
  enableStepper(false);
  return true;
}

//////////////////////
// Setup & Loop
//////////////////////

void connectWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to WiFi");
  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED && attempts < 30) {
    delay(500);
    Serial.print(".");
    attempts++;
  }
  Serial.println();
  if (WiFi.status() == WL_CONNECTED) {
    Serial.print("Connected. IP: ");
    Serial.println(WiFi.localIP());
  } else {
    Serial.println("WiFi not connected.");
  }
}

void setup() {
  Serial.begin(115200);
  delay(1000);

  pinMode(SELECT_BUTTON_PIN, INPUT_PULLUP);
  pinMode(IR_SENSOR_PIN, INPUT_PULLUP);
  pinMode(LED_STATUS_PIN, OUTPUT);
  digitalWrite(LED_STATUS_PIN, LOW);

  // OLED init
  Wire.begin(OLED_SDA, OLED_SCL);
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("SSD1306 allocation failed");
    for(;;); // stop
  }
  display.clearDisplay();
  display.display();

  showMessage("Vending Machine", "Initializing...");

  // Stepper
  setupStepper();

  // WiFi
  connectWiFi();

  delay(500);
  showProductList();
  Serial.println("Setup complete.");
}

unsigned long lastPollTime = 0;
const unsigned long POLL_INTERVAL_MS = 3000;

void loop() {
  // Simple UI: use SELECT_BUTTON_PIN to cycle selection and long press to buy
  static unsigned long btnLast = 0;
  static bool btnPrevState = HIGH;
  bool btnState = digitalRead(SELECT_BUTTON_PIN);
  if (btnState == LOW && btnPrevState == HIGH) {
    // button pressed - short press = next product
    btnLast = millis();
  }
  if (btnState == HIGH && btnPrevState == LOW) {
    unsigned long pressLen = millis() - btnLast;
    if (pressLen < 800) {
      // short press
      selectedProductIndex = (selectedProductIndex + 1) % productCount;
      showProductList();
    } else {
      // long press => buy
      if (products[selectedProductIndex].stock <= 0) {
        showMessage("محصول ناموجود است", products[selectedProductIndex].name);
        delay(1500);
        showProductList();
      } else {
        // Start purchase flow
        Serial.printf("Start purchase: %s\n", products[selectedProductIndex].id);
        digitalWrite(LED_STATUS_PIN, HIGH);
        showMessage("در حال ایجاد سفارش...", products[selectedProductIndex].name);
        String paymentUrl = httpPostCreateOrder(products[selectedProductIndex].id, products[selectedProductIndex].price);
        if (paymentUrl.length() == 0) {
          showMessage("خطا در ایجاد سفارش", "لطفا دوباره تلاش کنید");
          digitalWrite(LED_STATUS_PIN, LOW);
          delay(2000);
          showProductList();
        } else {
          // Show QR and URL
          showMessage("لطفا پرداخت کنید", "لینک در OLED نمایش داده شده");
          delay(800);
          drawQRCodeOnOLED(paymentUrl); // show big QR
          // Also print URL to serial
          Serial.println("Payment URL:");
          Serial.println(paymentUrl);
          waitingForPayment = true;
          paymentRequestTime = millis();
          // Polling loop for payment
          while (waitingForPayment) {
            if (millis() - paymentRequestTime > PAYMENT_TIMEOUT_MS) {
              showMessage("زمان پرداخت تمام شد", "سفارش لغو شد");
              waitingForPayment = false;
              currentOrderId = "";
              digitalWrite(LED_STATUS_PIN, LOW);
              delay(1500);
              showProductList();
              break;
            }
            if (millis() - lastPollTime >= POLL_INTERVAL_MS) {
              lastPollTime = millis();
              if (currentOrderId.length() == 0) {
                Serial.println("No order id? abort.");
                waitingForPayment = false;
                break;
              }
              String status = httpGetOrderStatus(currentOrderId.c_str());
              Serial.printf("Order status: %s\n", status.c_str());
              if (status == "paid") {
                // Release product
                showMessage("پرداخت موفق!", "در حال تحویل کالا...");
                bool released = releaseProduct(products[selectedProductIndex].stepsToRelease);
                if (!released) {
                  showMessage("خطا در تحویل", "لطفا تماس بگیرید");
                } else {
                  // wait sensor
                  bool dropped = waitForProductDrop(10000); // 10s
                  if (dropped) {
                    showMessage("تحویل با موفقیت انجام شد", products[selectedProductIndex].name);
                    products[selectedProductIndex].stock -= 1;
                  } else {
                    showMessage("تحویل ناموفق", "بازگشت وجه یا کمک");
                    // Optionally trigger refund flow via server
                  }
                }
                waitingForPayment = false;
                currentOrderId = "";
                digitalWrite(LED_STATUS_PIN, LOW);
                delay(1500);
                showProductList();
                break;
              } else if (status == "failed") {
                showMessage("پرداخت ناموفق", "لطفا دوباره تلاش کنید");
                waitingForPayment = false;
                currentOrderId = "";
                digitalWrite(LED_STATUS_PIN, LOW);
                delay(1500);
                showProductList();
                break;
              } else {
                // still pending - show waiting message maybe with countdown
                // we already display QR; update can be skipped
              }
            }
            delay(100);
          } // end polling while
        } // end if paymentUrl
      } // end else stock
    } // end long press branch
  } // end button release handling

  btnPrevState = btnState;

  // small delay to debounce
  delay(50);
}