Arduino.ino

#include <HX711_ADC.h>
#include <Servo.h>
#include <SoftwareSerial.h>
#include <LiquidCrystal_I2C.h>

// ---------------------- LCD ----------------------
LiquidCrystal_I2C lcd(0x27, 16, 2);

// ---------------------- Pins ----------------------
const int acceptRejectServoPin = 10;
const int coinServoPin = 6;
const int startSaveButtonPin = 2;
const int claimButtonPin = 11;
const int cancelButtonPin = 3;
const int irPin = 7;

// ---------------------- Servos ----------------------
Servo acceptRejectServo;
Servo coinServo;

// ---------------------- QR Scanner ----------------------
SoftwareSerial qrSerial(8, 9); // RX=8, TX=9 for QR scanner

// ---------------------- HX711 ----------------------
HX711_ADC LoadCell(12, 13);
float calibrationFactor = 1000.0;

// ---------------------- CAPACITIVE + INDUCTIVE ----------------------
const int inductivePin = 4;
const int SIG = A0;
const int DIG = A2;

// ---------------------- State ----------------------
String qrData = "";
bool collecting = false;
bool waitingForQR_Save = false;
bool waitingForQR_Claim = false;
bool waitingForStable = false;
unsigned long stableStartTime = 0;
const unsigned long stabilizationTime = 3000UL;
int bottleCount = 0;
bool proceedPrinted = false;

// ---------------- SENSOR BLOCK SETTINGS ----------------
const unsigned long inductiveWaitTime = 3000;
const unsigned long stableDelay = 200;
const unsigned long weightStabilization = 2000;
bool metalState = false;

// ---------------------- LCD Helper ----------------------
void lcdPrint(String l1, String l2 = "") {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(l1);
  lcd.setCursor(0, 1);
  lcd.print(l2);
}

// ---------------------- Buttons ----------------------
bool buttonPressed(int pin) {
  if (digitalRead(pin) == LOW) {
    delay(30);
    return digitalRead(pin) == LOW;
  }
  return false;
}

// ---------------------- QR Extract ----------------------
String extractID(String raw) {
  raw.trim();
  int pos = raw.lastIndexOf('=');
  if (pos != -1 && pos + 1 < raw.length())
    return raw.substring(pos + 1);
  return raw;
}

// Non-blocking QR scanner
bool scanQRCodeOnce() {
  while (qrSerial.available()) {
    char c = qrSerial.read();
    if (c == '\n' || c == '\r') {
      if (qrData.length() > 0) {
        qrData.trim();
        qrData = extractID(qrData);
        Serial.print("QR_CODE:");
        Serial.println(qrData);
        lcdPrint("QR Received", qrData);
        qrData = "";
        return true;
      }
    } else {
      qrData += c;
    }
  }
  return false;
}

// ---------------------- Servo Reward ----------------------
void dispenseMoves(int moves, bool waitBefore = false) {
  if (moves <= 0) return;
  if (waitBefore) {
    lcdPrint("Processing...");
    delay(2000);
  }
  for (int i = 0; i < moves; i++) {
    coinServo.write(180);
    delay(400);
    coinServo.write(0);
    delay(400);
  }
  lcdPrint("Reward", "Dispensed!");
  delay(1000);
}

// ---------------------- ESP32 Messages ----------------------
void handleSerialFromESP() {
  while (Serial.available()) {
    String line = Serial.readStringUntil('\n');
    line.trim();

    if (line.startsWith("DISPENSE:")) {
      int moves = line.substring(9).toInt();
      dispenseMoves(moves);
    }
    // Corrected CLAIM_MOVES handling
    else if (line.startsWith("CLAIM_MOVES:")) {
      // Extract the number of moves from the line, starting after "CLAIM_MOVES:"
      int moves = line.substring(12).toInt();

      if (moves == 0) {
        Serial.println("Insufficient points!");
        lcdPrint("Need more", "points"); // Updated LCD message for clarity
        delay(2000);
        return;
      }
      
      // If moves > 0 (5, 6, 7, 8, 9, or 10):
      Serial.print("Servo moves for redemption: "); // Corrected Serial Output
      Serial.println(moves);
      lcdPrint("Redeeming", "rewards..."); // Corrected LCD message

      // This is the function that physically moves the servo 'moves' times
      dispenseMoves(moves, true);
    }
  }
}

// ---------------------- Setup ----------------------
void setup() {
  pinMode(startSaveButtonPin, INPUT_PULLUP);
  pinMode(claimButtonPin, INPUT_PULLUP);
  pinMode(cancelButtonPin, INPUT_PULLUP);
  pinMode(irPin, INPUT_PULLUP);
  pinMode(inductivePin, INPUT);
  pinMode(DIG, INPUT);

  acceptRejectServo.attach(acceptRejectServoPin);
  coinServo.attach(coinServoPin);
  acceptRejectServo.write(90);
  coinServo.write(0);

  Serial.begin(9600);
  qrSerial.begin(9600);

  lcd.init();
  lcd.backlight();
  lcdPrint("Initializing...");

  LoadCell.begin();
  LoadCell.start(2000);
  LoadCell.setCalFactor(calibrationFactor);

  lcdPrint("System Ready");
  Serial.println("System Ready");
}

// ==================================================
//                WEIGHT SENSOR PROCESS
// ==================================================
void runWeightProcess() {
  Serial.println("⚡ Stabilizing weight...");
  unsigned long startTime = millis();
  float stableWeight = 0;
  int samples = 0;

  while (millis() - startTime < weightStabilization) {
    LoadCell.update();
    float w = LoadCell.getData();
    stableWeight += w;
    samples++;
    delay(100);
  }

  stableWeight /= samples;

  Serial.print("Final Weight: ");
  Serial.print(stableWeight, 2);
  Serial.println(" g");

  if (stableWeight >= 35 && stableWeight <= 80) {
    Serial.println("✅ Bottle accepted");
    lcdPrint("Bottle OK", "Count: " + String(++bottleCount));
    acceptRejectServo.write(0);
    delay(600);
    acceptRejectServo.write(90);
  }
  else if (stableWeight < 34) {
    Serial.println("❌ Too light, rejected");
    lcdPrint("Rejected", "Too Light");
    acceptRejectServo.write(180);
    delay(600);
    acceptRejectServo.write(90);
  }
  else {
    Serial.println("⚠️ Too heavy or invalid");
    lcdPrint("Rejected", "Too Heavy");
    acceptRejectServo.write(180);
    delay(600);
    acceptRejectServo.write(90);
  }

  Serial.println("Waiting for object removal...");
  while (LoadCell.getData() > 5) LoadCell.update();
  Serial.println("🟡 Object removed. Ready.");
}

// ---------------------- Loop ----------------------
void loop() {
  LoadCell.update();
  handleSerialFromESP();

  // -------- CANCEL --------
  if (buttonPressed(cancelButtonPin)) {
    if (!collecting && !waitingForQR_Save && !waitingForQR_Claim) {
      Serial.println("No transactions yet");
      lcdPrint("No Transaction", "Yet");
      delay(2000);
      lcdPrint("System Ready");
      return;
    }

    Serial.println("Cancelling Process...");
    lcdPrint("Cancelling", "Process...");
    delay(2000);

    collecting = false;
    waitingForStable = false;
    waitingForQR_Save = false;
    waitingForQR_Claim = false;
    qrData = "";
    bottleCount = 0;
    proceedPrinted = false;

    lcdPrint("System Ready");
    delay(300);
  }

  // -------- START / SAVE --------
  if (!waitingForQR_Claim) {
    if (buttonPressed(startSaveButtonPin) && !collecting) {
      collecting = true;
      bottleCount = 0;
      Serial.println("START");
      lcdPrint("Insert bottles");
      delay(300);
    }
    else if (buttonPressed(startSaveButtonPin) && collecting && !waitingForQR_Save) {
      qrData = "";
      waitingForQR_Save = true;
      Serial.print("TOTAL_BOTTLES:");
      Serial.println(bottleCount);
      Serial.println("SAVE");
      lcdPrint("Scan QR", "to Save");
      delay(300);
    }
  }

  // ---------------------- BOTTLE DETECTION ----------------------
  if (collecting && !waitingForQR_Save) {
    if (digitalRead(irPin) == LOW) {
      Serial.println("Object Detected");
      lcdPrint("Object Detected", "");
      delay(100);

      metalState = false;
      unsigned long startCheck = millis();
      unsigned long lastHighTime = millis();

      while (millis() - startCheck < inductiveWaitTime) {
        int reading = digitalRead(inductivePin);
        unsigned long t = millis();
        if (reading == HIGH) lastHighTime = t;
        if (!metalState && (t - lastHighTime) >= stableDelay) {
          Serial.println("Rejected, object is metal");
          lcdPrint("REJECTED", "Metal");
          acceptRejectServo.write(180);
          delay(600);
          acceptRejectServo.write(90);
          return;
        }
      }

      Serial.println("No Metal – Proceed to Weighing...");
      lcdPrint("Checking Weight");
      runWeightProcess();
      delay(500);
    }
  }

///------------ QR SAVE -------------
if (waitingForQR_Save && scanQRCodeOnce()) {
    waitingForQR_Save = false;
    collecting = false;

    // RESET ALL IMPORTANT VALUES
    qrData = "";
    bottleCount = 0;
    proceedPrinted = false;

    lcdPrint("Saving...");
    delay(3000);

    Serial.println("System Ready");
    lcdPrint("System Ready");
}


  // -------- QR CLAIM --------
 if (waitingForQR_Claim && scanQRCodeOnce()) {
    waitingForQR_Claim = false;

    // RESET ALL IMPORTANT VALUES
    qrData = "";
    proceedPrinted = false;

    lcdPrint("Processing...");
    delay(1500);
    Serial.println("System Ready");
    lcdPrint("System Ready");
}


  // -------- CLAIM BUTTON --------
  if (!collecting && !waitingForQR_Save) {
    if (buttonPressed(claimButtonPin) && !waitingForQR_Claim) {
      qrData = "";
      waitingForQR_Claim = true;
      Serial.println("CLAIM");
      lcdPrint("Scan QR", "to Claim");
      delay(300);
    }
  }
}