Beiträge von SoftCreatR

<?php
// PayPal
define('PAYPAL_CLIENT_ID', 'DEINE_CLIENT_ID');
define('PAYPAL_SECRET',    'DEIN_SECRET');

// Gib hier die API-Umgebung an:
// - "api-m.sandbox.paypal.com" für Sandbox
// - "api-m.paypal.com"       für Live
define('PAYPAL_API_BASE',  'https://api-m.sandbox.paypal.com');

// Shelly
define('SHELLY_IP',        '192.168.1.50'); // IP deines Shelly-Geräts
define('SHELLY_RELAY',     0);             // In der Regel "0" für den ersten Relais-Kanal

// Waschmaschine
define('POWER_THRESHOLD',  10);            // Beispielschwelle (in Watt), ab der die Maschine als "läuft" gilt
define('RUNTIME_IN_HOURS', 3);             // Laufzeit, die nach Freischaltung gewährt wird

// MySQL
define('DB_HOST', 'localhost');
define('DB_NAME', 'shelly_wama');
define('DB_USER', 'root');
define('DB_PASS', '');

<?php

require_once 'config.php';

/**
 * Gibt ein Access Token für PayPal zurück.
 */
function getPayPalAccessToken(): ?string
{
    $url = PAYPAL_API_BASE . "/v1/oauth2/token";
    $auth = base64_encode(PAYPAL_CLIENT_ID . ":" . PAYPAL_SECRET);

    $headers = [
        "Authorization: Basic $auth",
        "Content-Type: application/x-www-form-urlencoded",
    ];

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_POSTFIELDS, "grant_type=client_credentials");
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);
    if ($response === false) {
        return null;
    }
    curl_close($ch);

    $data = json_decode($response, true);
    return $data['access_token'] ?? null;
}

/**
 * Holt Informationen zu einem PayPal-Order (Bezahlvorgang).
 */
function getPayPalOrderDetails(string $orderId, string $accessToken): ?array
{
    $url = PAYPAL_API_BASE . "/v2/checkout/orders/$orderId";
    $headers = [
        "Authorization: Bearer $accessToken",
        "Content-Type: application/json",
    ];

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);
    if ($response === false) {
        return null;
    }
    curl_close($ch);

    $data = json_decode($response, true);
    return $data;
}

/**
 * Schaltet das Shelly-Relais an oder aus.
 * @param string $state 'on' oder 'off'
 */
function switchShellyRelay(string $state): bool
{
    $url = "http://" . SHELLY_IP . "/relay/" . SHELLY_RELAY;
    $data = http_build_query(['turn' => $state]);

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $response = curl_exec($ch);
    curl_close($ch);

    return $response !== false;
}

/**
 * Fragt den aktuellen Stromverbrauch (Watt) des Shelly 1PM ab.
 */
function getShellyPower(): float
{
    $url = "http://" . SHELLY_IP . "/status";

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    if ($response === false) {
        return 0.0;
    }

    $data = json_decode($response, true);
    // Je nach Shelly-Typ kann die Struktur leicht variieren:
    return $data['meters'][0]['power'] ?? 0.0;
}

/**
 * Stellt fest, ob die Waschmaschine läuft.
 */
function isWashingMachineRunning(): bool
{
    $power = getShellyPower();
    return $power > POWER_THRESHOLD;
}

/**
 * Datenbank-Funktionen
 */
function dbConnect(): ?PDO
{
    try {
        return new PDO('mysql:host='.DB_HOST.';dbname='.DB_NAME, DB_USER, DB_PASS, [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
        ]);
    } catch (PDOException $e) {
        // Im Fehlerfall null zurückgeben oder Exception werfen
        return null;
    }
}

/**
 * Speicherung einer Transaktion
 */
function saveTransaction(string $orderId, string $status): void
{
    $pdo = dbConnect();
    if (!$pdo) {
        return;
    }
    $stmt = $pdo->prepare("INSERT INTO transactions (order_id, status, created_at) VALUES (:oid, :status, NOW())");
    $stmt->execute([
        ':oid'    => $orderId,
        ':status' => $status
    ]);
}

<?php

require_once 'functions.php';

// Prüfe, ob die "orderID" vorhanden ist
if (!isset($_GET['orderID'])) {
    exit("Keine Order-ID vorhanden.");
}

$orderId = $_GET['orderID'];

// 1. Access Token holen
$accessToken = getPayPalAccessToken();
if (!$accessToken) {
    exit("Fehler beim Abrufen des PayPal Access Tokens.");
}

// 2. Order-Details abfragen
$orderDetails = getPayPalOrderDetails($orderId, $accessToken);
if (!$orderDetails || !isset($orderDetails['status'])) {
    exit("Fehler beim Abrufen der Zahlungsdetails.");
}

// 3. Bestätigen, dass Zahlung erfolgreich (COMPLETED) ist
if ($orderDetails['status'] !== 'COMPLETED') {
    exit("Zahlung nicht abgeschlossen. Status: " . $orderDetails['status']);
}

// Transaktion speichern
saveTransaction($orderId, $orderDetails['status']);

// 4. Status der Waschmaschine prüfen
if (isWashingMachineRunning()) {
    // Wenn die Maschine läuft, abbrechen oder Meldung ausgeben
    echo "Die Waschmaschine ist bereits in Betrieb. Bitte warte, bis sie frei wird.";
    exit;
}

// 5. Shelly-Relais einschalten (Waschmaschine einschalten)
if (switchShellyRelay('on')) {
    // Zeitstempel merken (z. B. in einer DB, hier nur als Session-Beispiel)
    session_start();
    $_SESSION['washer_enabled_at'] = time();
    echo "Waschmaschine wurde für " . RUNTIME_IN_HOURS . " Stunden freigeschaltet.";
} else {
    echo "Fehler beim Einschalten der Waschmaschine.";
}

<?php
require_once 'functions.php';

try {
    $pdo = dbConnect();
    if (!$pdo) {
        // Falls keine Verbindung aufgebaut werden kann, einfach beenden
        exit("Datenbankverbindung fehlgeschlagen.\n");
    }

    // 1) Alle aktiven Transaktionen suchen, bei denen das Ablaufdatum <= jetzt ist
    $stmt = $pdo->query("
        SELECT id, order_id 
        FROM transactions
        WHERE is_active = 1
          AND ends_at <= NOW()
    ");

    $expiredTransactions = $stmt->fetchAll(PDO::FETCH_ASSOC);

    // 2) Für jede abgelaufene Freischaltung: Waschmaschine ausschalten
    foreach ($expiredTransactions as $tx) {
        echo "Freischaltung abgelaufen für Order-ID: {$tx['order_id']}. Schalte Waschmaschine ab.\n";

        // Shelly-Relais ausschalten
        $success = switchShellyRelay('off');

        if ($success) {
            // 3) Transaktion in DB auf 'inaktiv' setzen
            $updateStmt = $pdo->prepare("
                UPDATE transactions
                SET is_active = 0
                WHERE id = :id
            ");
            $updateStmt->execute([':id' => $tx['id']]);
            echo "Waschmaschine erfolgreich deaktiviert.\n";
        } else {
            echo "Fehler: Konnte Shelly-Relais nicht ausschalten.\n";
        }
    }

    // Optional: Wenn du mehrere Waschmaschinen oder mehrere Transaktionen parallel verwaltest,
    // passt du diesen Vorgang entsprechend an. 
    // Hier haben wir nur ein Shelly-Relais (eine Waschmaschine) pro Transaktion angenommen.

} catch (Exception $e) {
    // Fehlerbehandlung
    echo "Fehler in cron.php: " . $e->getMessage() . "\n";
}

<?php
require_once 'config.php';
?>
<!DOCTYPE html>
<html lang="de">
<head>
  <meta charset="UTF-8">
  <title>Waschmaschine - Smart Payment</title>
</head>
<body>
  <h1>Waschmaschine freischalten</h1>
  <p>Preis pro Waschgang: 2,50 EUR</p>

  <!-- PayPal Buttons integrieren (Achtung: Sandbox-Link vs. Live-Link) -->
  <script src="https://www.paypal.com/sdk/js?client-id=<?php echo PAYPAL_CLIENT_ID; ?>&currency=EUR"></script>

  <div id="paypal-button-container"></div>
  <script>
    paypal.Buttons({
      createOrder: function(data, actions) {
        return actions.order.create({
          purchase_units: [{
            amount: {
              value: '2.50' // Preis anpassen
            }
          }]
        });
      },
      onApprove: function(data, actions) {
        return actions.order.capture().then(function(details) {
          // Nach erfolgreicher Zahlung an callback.php senden
          window.location.href = 'callback.php?orderID=' + data.orderID;
        });
      }
    }).render('#paypal-button-container');
  </script>
</body>
</html>

// Ampelsteuerung für Shelly Plus RGBW PM
// ===================================================
//
// Ampel-Zustände:
// 0              = alles aus
// Gelb blinken:  101 (gelb ein), 102 (gelb aus, dann zurück zu 101)
// Normale Ampel: 201...208 (Grün -> Gelb -> Rot -> Rot+Gelb)
// Lauflicht:     301...308 (Rot -> Gelb -> Grün -> Rot ... zyklisch)
//
// Eingänge (Schalter) bestimmen, in welchem Modus die Ampel läuft:
// Schalter-Kombinationen (summe der aktivierten Eingänge):
// 0 = alles aus
// 1 = Gelb blinkend
// 2 = normale Ampel
// 3 = Lauflicht
// 4 = alles aus
//
// Die Eingänge werden einzeln abgefragt (S1...S4) und über einfache
// Additionen zu einer "Schalter"-Variable kombiniert, um den Modus zu wählen.

// ============================
// Konfiguration & Konstanten
// ============================

const BRIGHTNESS = 15;       // Standard-Helligkeit
const LOOP_INTERVAL = 500;   // Intervall für den Hauptloop (ms)

// Zustände definieren (Konstanten für bessere Lesbarkeit)
const STATES = {
  OFF: 0,

  YELLOW_BLINK_ON: 101,
  YELLOW_BLINK_OFF: 102,

  NORMAL_GREEN_START: 201,
  NORMAL_GREEN: 202,
  NORMAL_YELLOW_START: 203,
  NORMAL_YELLOW: 204,
  NORMAL_RED_START: 205,
  NORMAL_RED: 206,
  NORMAL_RED_YELLOW_START: 207,
  NORMAL_RED_YELLOW: 208,

  RUN_START: 301,
  RUN_WAIT_1: 302,
  RUN_SWITCH_YELLOW: 303,
  RUN_WAIT_2: 304,
  RUN_SWITCH_GREEN: 305,
  RUN_WAIT_3: 306,
  RUN_SWITCH_RED: 307,
  RUN_WAIT_4: 308,
};

// Dauer der einzelnen Phasen (wie oft Loop durchlaufen wird, bis nächster Schritt)
const TIMINGS = {
  NORMAL_GREEN: 6,
  NORMAL_YELLOW: 4,
  NORMAL_RED: 6,
  NORMAL_RED_YELLOW: 2,

  RUN_PHASE: 2, // Wartezeit für jede Lauflicht-Zwischenphase
};

// ============================
// Globale Variablen
// ============================

let Ampel = STATES.OFF;  
let LoopCount = 0;
let oldSchalter = 10; // Startwert für Schalter, um initialen Wechsel zu erkennen

// ============================
// Hilfsfunktionen
// ============================

// Alle Kanäle ausschalten
function AlleAus() {
  for (let i = 0; i < 4; i++) {
    Shelly.call("Light.set", { id: i, on: false, brightness: BRIGHTNESS });
  }
}

// Eingänge (Schalter) auslesen und kombinierten Wert zurückgeben
function readInputs() {
  const S1 = Shelly.getComponentStatus("input:0").state ? 1 : 0;
  const S2 = Shelly.getComponentStatus("input:1").state ? 2 : 0;
  const S3 = Shelly.getComponentStatus("input:2").state ? 3 : 0;
  const S4 = Shelly.getComponentStatus("input:3").state ? 4 : 0;

  // Summe bildet den "Schalter"-Wert
  return S1 + S2 + S3 + S4;
}

// Ampel-Wert anpassen, wenn sich der Schalterzustand ändert
function updateAmpelFromInputs() {
  const Schalter = readInputs();
  if (oldSchalter !== Schalter) {
    switch (Schalter) {
      case 0:
        Ampel = STATES.OFF;
        break;
      case 1:
        Ampel = STATES.YELLOW_BLINK_ON;
        break;
      case 2:
        Ampel = STATES.NORMAL_GREEN_START;
        break;
      case 3:
        Ampel = STATES.RUN_START;
        break;
      case 4:
        Ampel = STATES.OFF;
        break;
      default:
        Ampel = STATES.OFF; // Fallback, falls unerwarteter Wert
        break;
    }
    print(`Old: ${oldSchalter} Neu: ${Schalter} Ampel: ${Ampel} (${typeof Ampel})`);
    oldSchalter = Schalter;
  }
}

// Zustandslogik anwenden, abhängig von Ampel
function applyState() {
  switch (Ampel) {
    case STATES.OFF:
      AlleAus();
      break;

    // Gelb blinken
    case STATES.YELLOW_BLINK_ON:
      print("Blinklicht AN");
      Shelly.call("Light.set", { id: 1, on: true });
      Ampel = STATES.YELLOW_BLINK_OFF;
      break;

    case STATES.YELLOW_BLINK_OFF:
      Shelly.call("Light.setAll", { on: false });
      Ampel = STATES.YELLOW_BLINK_ON;
      break;

    // Normale Ampel
    case STATES.NORMAL_GREEN_START:
      print("Normale Ampel: Grünphase starten");
      Shelly.call("Light.set", { id: 2, on: true }); // Grün an
      Shelly.call("Light.set", { id: 1, on: false }); // Gelb aus
      Shelly.call("Light.set", { id: 0, on: false }); // Rot aus
      LoopCount = 0;
      Ampel = STATES.NORMAL_GREEN;
      break;

    case STATES.NORMAL_GREEN:
      LoopCount++;
      if (LoopCount > TIMINGS.NORMAL_GREEN) {
        Ampel = STATES.NORMAL_YELLOW_START;
      }
      break;

    case STATES.NORMAL_YELLOW_START:
      Shelly.call("Light.set", { id: 1, on: true });  // Gelb an
      Shelly.call("Light.set", { id: 2, on: false }); // Grün aus
      LoopCount = 0;
      Ampel = STATES.NORMAL_YELLOW;
      break;

    case STATES.NORMAL_YELLOW:
      LoopCount++;
      if (LoopCount > TIMINGS.NORMAL_YELLOW) {
        Ampel = STATES.NORMAL_RED_START;
      }
      break;

    case STATES.NORMAL_RED_START:
      Shelly.call("Light.set", { id: 0, on: true });  // Rot an
      Shelly.call("Light.set", { id: 1, on: false }); // Gelb aus
      LoopCount = 0;
      Ampel = STATES.NORMAL_RED;
      break;

    case STATES.NORMAL_RED:
      LoopCount++;
      if (LoopCount > TIMINGS.NORMAL_RED) {
        Ampel = STATES.NORMAL_RED_YELLOW_START;
      }
      break;

    case STATES.NORMAL_RED_YELLOW_START:
      LoopCount = 0;
      Shelly.call("Light.set", { id: 1, on: true }); // Gelb an
      Ampel = STATES.NORMAL_RED_YELLOW;
      break;

    case STATES.NORMAL_RED_YELLOW:
      LoopCount++;
      if (LoopCount > TIMINGS.NORMAL_RED_YELLOW) {
        Ampel = STATES.NORMAL_GREEN_START; // Zyklus von vorn (Grünphase)
      }
      break;

    // Lauflicht
    case STATES.RUN_START:
      print("Lauflicht starten");
      AlleAus();
      LoopCount = 0;
      Shelly.call("Light.set", { id: 0, on: true }); // Rot an
      Ampel = STATES.RUN_WAIT_1;
      break;

    case STATES.RUN_WAIT_1:
      LoopCount++;
      if (LoopCount > TIMINGS.RUN_PHASE) {
        Ampel = STATES.RUN_SWITCH_YELLOW;
      }
      break;

    case STATES.RUN_SWITCH_YELLOW:
      Shelly.call("Light.set", { id: 0, on: false });
      Shelly.call("Light.set", { id: 1, on: true });
      LoopCount = 0;
      Ampel = STATES.RUN_WAIT_2;
      break;

    case STATES.RUN_WAIT_2:
      LoopCount++;
      if (LoopCount > TIMINGS.RUN_PHASE) {
        Ampel = STATES.RUN_SWITCH_GREEN;
      }
      break;

    case STATES.RUN_SWITCH_GREEN:
      Shelly.call("Light.set", { id: 1, on: false });
      Shelly.call("Light.set", { id: 2, on: true });
      LoopCount = 0;
      Ampel = STATES.RUN_WAIT_3;
      break;

    case STATES.RUN_WAIT_3:
      LoopCount++;
      if (LoopCount > TIMINGS.RUN_PHASE) {
        Ampel = STATES.RUN_SWITCH_RED;
      }
      break;

    case STATES.RUN_SWITCH_RED:
      Shelly.call("Light.set", { id: 2, on: false });
      Shelly.call("Light.set", { id: 0, on: true });
      LoopCount = 0;
      Ampel = STATES.RUN_WAIT_4;
      break;

    case STATES.RUN_WAIT_4:
      LoopCount++;
      if (LoopCount > TIMINGS.RUN_PHASE) {
        Ampel = STATES.RUN_WAIT_1; // Zurück zum Start des Laufs (Endlos-Schleife)
      }
      break;

    default:
      // Unerwarteter Zustand: Sicherheitshalber alles aus und zurück auf OFF
      AlleAus();
      Ampel = STATES.OFF;
      break;
  }
}

// Haupt-Schleifenfunktion, wird alle LOOP_INTERVAL ms aufgerufen
function loop() {
  updateAmpelFromInputs();
  applyState();
}

// Initialisierung: alles aus
AlleAus();

// Timer setzen für die Hauptschleife
Timer.set(LOOP_INTERVAL, true, loop);