Tap to pay with x402

#include <WiFi.h>
#include "X402Aurdino.h"
#include "x4pay-core.h"

// WiFi credentials
const char* ssid = "YourWiFi";
const char* password = "YourPassword";

// Payment configuration
const String DEVICE_NAME = "Coffee Machine";
const String NETWORK = "base-sepolia";
const String PAY_TO = "0xYourAddress";
const String LOGO = "https://example.com/coffee-logo.jpg";
const String DESCRIPTION = "Fresh coffee payments";

// Coffee options and pins
const String coffeeOptions[] = {"Espresso", "Americano", "Latte", "Cappuccino"};
const int relayPins[] = {2, 4, 5, 18}; // GPIO pins for relays
const int statusLED = 19;

X402Ble* coffeeMachine;

// Dynamic pricing based on coffee type
String calculatePrice(const std::vector<String>& options, const String& context) {
  for (const auto& option : options) {
    if (option == "Latte" || option == "Cappuccino") {
      return "2000000"; // 2 USDC for specialty drinks
    }
  }
  return "1000000"; // 1 USDC for regular coffee
}

// Payment success callback
void onPaymentSuccess(const std::vector<String>& options, const String& context) {
  Serial.println("Payment received! Making coffee...");
  digitalWrite(statusLED, HIGH);
  
  // Activate appropriate relay based on selection
  for (const auto& option : options) {
    for (int i = 0; i < 4; i++) {
      if (option == coffeeOptions[i]) {
        digitalWrite(relayPins[i], HIGH);
        delay(5000); // Run for 5 seconds
        digitalWrite(relayPins[i], LOW);
        break;
      }
    }
  }
  
  digitalWrite(statusLED, LOW);
  Serial.println("Coffee ready!");
}

void setup() {
  Serial.begin(115200);
  
  // Initialize pins
  for (int i = 0; i < 4; i++) {
    pinMode(relayPins[i], OUTPUT);
    digitalWrite(relayPins[i], LOW);
  }
  pinMode(statusLED, OUTPUT);
  
  // Connect to WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  Serial.println("WiFi connected!");
  
  // Create payment device
  coffeeMachine = new X402Ble(DEVICE_NAME, "1000000", PAY_TO, NETWORK, 
                              LOGO, DESCRIPTION, "");
  
  // Configure options and callbacks
  coffeeMachine->enableOptions(coffeeOptions, 4);
  coffeeMachine->setDynamicPriceCallback(calculatePrice);
  coffeeMachine->setOnPay(onPaymentSuccess);
  
  // Start BLE service
  coffeeMachine->begin();
  Serial.println("Coffee machine ready for payments!");
}

void loop() {
  // Check for completed payments
  if (coffeeMachine->getStatusAndReset()) {
    Serial.println("New payment processed");
  }
  delay(100);
}

#include <WiFi.h>
#include <ESP32Servo.h>
#include "X402Aurdino.h"
#include "x4pay-core.h"

// WiFi and payment setup
const char* ssid = "YourWiFi";
const char* password = "YourPassword";
const String DEVICE_NAME = "Bike Rental";
const String NETWORK = "base-sepolia";
const String PAY_TO = "0xYourAddress";

// Hardware pins
const int servoPin = 9;
const int lockLED = 2;
const int unlockLED = 4;

Servo lockServo;
X402Ble* bikeRental;
bool isUnlocked = false;
unsigned long unlockTime = 0;

// Rental periods (in minutes)
const String rentalOptions[] = {"15 min", "30 min", "60 min", "24 hours"};

String calculateRentalPrice(const std::vector<String>& options, const String& context) {
  for (const auto& option : options) {
    if (option == "15 min") return "1500000";  // $1.50
    if (option == "30 min") return "2500000";  // $2.50
    if (option == "60 min") return "4000000";  // $4.00
    if (option == "24 hours") return "15000000"; // $15.00
  }
  return "1500000"; // Default 15 min
}

void onRentalPayment(const std::vector<String>& options, const String& context) {
  Serial.println("Payment received! Unlocking bike...");
  
  // Unlock the bike
  lockServo.write(90); // Unlock position
  isUnlocked = true;
  unlockTime = millis();
  
  // Set unlock duration based on payment
  unsigned long duration = 15 * 60 * 1000; // Default 15 minutes
  for (const auto& option : options) {
    if (option == "30 min") duration = 30 * 60 * 1000;
    else if (option == "60 min") duration = 60 * 60 * 1000;
    else if (option == "24 hours") duration = 24 * 60 * 60 * 1000;
  }
  
  digitalWrite(unlockLED, HIGH);
  digitalWrite(lockLED, LOW);
  
  Serial.print("Bike unlocked for: ");
  Serial.println(options[0]);
}

void setup() {
  Serial.begin(115200);
  
  // Initialize hardware
  lockServo.attach(servoPin);
  lockServo.write(0); // Lock position
  pinMode(lockLED, OUTPUT);
  pinMode(unlockLED, OUTPUT);
  digitalWrite(lockLED, HIGH);
  digitalWrite(unlockLED, LOW);
  
  // Connect to WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  
  // Setup payment device
  bikeRental = new X402Ble(DEVICE_NAME, "1500000", PAY_TO, NETWORK, 
                           "", "Bike rental by the hour", "");
  
  bikeRental->enableOptions(rentalOptions, 4);
  bikeRental->setDynamicPriceCallback(calculateRentalPrice);
  bikeRental->setOnPay(onRentalPayment);
  bikeRental->begin();
  
  Serial.println("Bike rental system ready!");
}

void loop() {
  // Check if rental time expired
  if (isUnlocked && (millis() - unlockTime > 15 * 60 * 1000)) {
    // Lock the bike again
    lockServo.write(0);
    isUnlocked = false;
    digitalWrite(lockLED, HIGH);
    digitalWrite(unlockLED, LOW);
    Serial.println("Rental expired. Bike locked.");
  }
  
  delay(1000);
}

#include <WiFi.h>
#include <ESP32Servo.h>
#include <LiquidCrystal_I2C.h>
#include "X402Aurdino.h"
#include "x4pay-core.h"

// WiFi credentials
const char* ssid = "YourWiFi";
const char* password = "YourPassword";

// Payment configuration
const String DEVICE_NAME = "Snack Machine";
const String NETWORK = "base-sepolia";
const String PAY_TO = "0xYourAddress";

// Hardware setup
Servo dispenserServos[4];
LiquidCrystal_I2C lcd(0x27, 16, 2);
const int servoPins[] = {9, 10, 11, 12};
const int sensorPins[] = {2, 4, 5, 18};

// Product configuration
const String products[] = {"Chips", "Cookies", "Candy", "Nuts"};
const String prices[] = {"1000000", "1500000", "2000000", "2500000"}; // $1-2.50
int inventory[] = {10, 8, 12, 5}; // Stock levels

X402Ble* vendingMachine;

String getProductPrice(const std::vector<String>& options, const String& context) {
  for (const auto& option : options) {
    for (int i = 0; i < 4; i++) {
      if (option == products[i]) {
        return prices[i];
      }
    }
  }
  return "1000000"; // Default price
}

void dispenseProduct(const std::vector<String>& options, const String& context) {
  Serial.println("Payment confirmed! Dispensing product...");
  
  for (const auto& option : options) {
    for (int i = 0; i < 4; i++) {
      if (option == products[i] && inventory[i] > 0) {
        // Dispense product
        dispenserServos[i].write(90);
        delay(1000);
        dispenserServos[i].write(0);
        
        // Update inventory
        inventory[i]--;
        
        // Update display
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Dispensing:");
        lcd.setCursor(0, 1);
        lcd.print(option);
        
        Serial.print("Dispensed: ");
        Serial.println(option);
        
        delay(3000);
        updateDisplay();
        return;
      }
    }
  }
}

void updateDisplay() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Crypto Vending");
  lcd.setCursor(0, 1);
  lcd.print("Tap to pay");
}

void setup() {
  Serial.begin(115200);
  
  // Initialize LCD
  lcd.init();
  lcd.backlight();
  updateDisplay();
  
  // Initialize servos and sensors
  for (int i = 0; i < 4; i++) {
    dispenserServos[i].attach(servoPins[i]);
    dispenserServos[i].write(0);
    pinMode(sensorPins[i], INPUT);
  }
  
  // Connect to WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  
  // Setup vending machine
  vendingMachine = new X402Ble(DEVICE_NAME, "1000000", PAY_TO, NETWORK,
                               "", "Crypto snack vending", "");
  
  // Configure available products
  vendingMachine->enableOptions(products, 4);
  vendingMachine->setDynamicPriceCallback(getProductPrice);
  vendingMachine->setOnPay(dispenseProduct);
  vendingMachine->begin();
  
  Serial.println("Vending machine ready!");
}

void loop() {
  // Monitor inventory and update availability
  static unsigned long lastCheck = 0;
  if (millis() - lastCheck > 5000) { // Check every 5 seconds
    lastCheck = millis();
    
    // Update product options based on inventory
    std::vector<String> availableProducts;
    for (int i = 0; i < 4; i++) {
      if (inventory[i] > 0) {
        availableProducts.push_back(products[i]);
      }
    }
    
    // Log inventory status
    Serial.print("Inventory: ");
    for (int i = 0; i < 4; i++) {
      Serial.print(products[i]);
      Serial.print(":");
      Serial.print(inventory[i]);
      Serial.print(" ");
    }
    Serial.println();
  }
  
  delay(100);
}

#include <WiFi.h>
#include "X402Aurdino.h"
#include "x4pay-core.h"

// WiFi and payment setup
const char* ssid = "YourWiFi";
const char* password = "YourPassword";
const String DEVICE_NAME = "Parking Meter";
const String NETWORK = "base-sepolia";
const String PAY_TO = "0xYourAddress";

// Hardware pins
const int trigPin = 5;
const int echoPin = 18;
const int buzzerPin = 19;
const int displayPins[] = {2, 4, 16, 17}; // For 7-segment display

// Parking configuration
const String timeOptions[] = {"30 min", "1 hour", "2 hours", "4 hours"};
unsigned long parkingEndTime = 0;
bool carDetected = false;

X402Ble* parkingMeter;

String calculateParkingFee(const std::vector<String>& options, const String& context) {
  for (const auto& option : options) {
    if (option == "30 min") return "500000";   // $0.50
    if (option == "1 hour") return "1000000";  // $1.00
    if (option == "2 hours") return "1800000"; // $1.80
    if (option == "4 hours") return "3000000"; // $3.00
  }
  return "1000000"; // Default 1 hour
}

void onParkingPayment(const std::vector<String>& options, const String& context) {
  Serial.println("Parking payment received!");
  
  // Calculate parking duration
  unsigned long duration = 60 * 60 * 1000; // Default 1 hour in milliseconds
  for (const auto& option : options) {
    if (option == "30 min") duration = 30 * 60 * 1000;
    else if (option == "2 hours") duration = 2 * 60 * 60 * 1000;
    else if (option == "4 hours") duration = 4 * 60 * 60 * 1000;
  }
  
  parkingEndTime = millis() + duration;
  
  // Confirmation beep
  digitalWrite(buzzerPin, HIGH);
  delay(200);
  digitalWrite(buzzerPin, LOW);
  
  Serial.print("Parking paid for: ");
  Serial.println(options[0]);
}

float measureDistance() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  long duration = pulseIn(echoPin, HIGH);
  float distance = duration * 0.034 / 2; // Convert to cm
  
  return distance;
}

void displayTime(int minutes) {
  // Simple 7-segment display function
  // You would implement actual display logic here
  Serial.print("Time remaining: ");
  Serial.print(minutes);
  Serial.println(" minutes");
}

void setup() {
  Serial.begin(115200);
  
  // Initialize pins
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  
  // Initialize display pins
  for (int i = 0; i < 4; i++) {
    pinMode(displayPins[i], OUTPUT);
  }
  
  // Connect to WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  
  // Setup parking meter
  parkingMeter = new X402Ble(DEVICE_NAME, "1000000", PAY_TO, NETWORK,
                             "", "Digital parking payments", "");
  
  parkingMeter->enableOptions(timeOptions, 4);
  parkingMeter->setDynamicPriceCallback(calculateParkingFee);
  parkingMeter->setOnPay(onParkingPayment);
  parkingMeter->begin();
  
  Serial.println("Parking meter ready!");
}

void loop() {
  // Check for car presence
  float distance = measureDistance();
  carDetected = (distance < 200); // Car detected if within 2 meters
  
  // Check parking time
  if (parkingEndTime > 0) {
    if (millis() > parkingEndTime) {
      // Parking expired
      if (carDetected) {
        // Sound alarm for overtime parking
        digitalWrite(buzzerPin, HIGH);
        delay(100);
        digitalWrite(buzzerPin, LOW);
        delay(900);
      } else {
        // Car left, reset timer
        parkingEndTime = 0;
        Serial.println("Car left. Meter reset.");
      }
    } else {
      // Display remaining time
      unsigned long remaining = parkingEndTime - millis();
      int minutesLeft = remaining / (60 * 1000);
      displayTime(minutesLeft);
    }
  }
  
  delay(1000);
}