Mein Semesterferien-Projekt: der Stickformatter

#include "mongoose.h"
#include <iostream>
#include <chrono>
#include <thread>
#include <atomic>
#include <string>
#include <filesystem>
#include <gpiod.hpp>
#include <cstdlib>
#include <cstdio>
#include <array>
#include <sqlite3.h>
#include <mutex>

namespace fs = std::filesystem;

std::mutex statusMutex;
std::string currentStatus = "Warte auf Speichermedium...";

void setStatus(const std::string& msg) {
    std::lock_guard<std::mutex> lock(statusMutex);
    currentStatus = msg;
    std::cout << msg << std::endl;
}

std::string exec(const char* cmd) {
    std::array<char, 128> buffer;
    std::string result;
    int (*pclose_ptr)(FILE*) = pclose;
    std::unique_ptr<FILE, int(*)(FILE*)> pipe(popen(cmd, "r"), pclose_ptr);
    if (!pipe) return "";
    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
        result += buffer.data();
    }
    if (!result.empty() && result.back() == '\n') result.pop_back();
    return result;
}

void logToDatabase(long long duration, const std::string& usedSpace, bool formatSuccess, bool alreadyFormatted) {
    sqlite3* db;
    if (sqlite3_open("speicherlog.db", &db) == SQLITE_OK) {
        std::string sqlCreateTable = "CREATE TABLE IF NOT EXISTS logs ("
            "id INTEGER PRIMARY KEY AUTOINCREMENT,"
            "eingesteckt_um DATETIME DEFAULT (datetime('now', 'localtime')),"
            "dauer_ms INTEGER,"
            "belegter_platz TEXT,"
            "formatierung_erfolgreich BOOLEAN,"
            "war_schon_formatiert BOOLEAN);";
        sqlite3_exec(db, sqlCreateTable.c_str(), 0, 0, 0);

        std::string sqlInsert = "INSERT INTO logs (dauer_ms, belegter_platz, formatierung_erfolgreich, war_schon_formatiert) VALUES ("
            + std::to_string(duration) + ", '"
            + usedSpace + "', "
            + (formatSuccess ? "1" : "0") + ", "
            + (alreadyFormatted ? "1" : "0") + ");";
        sqlite3_exec(db, sqlInsert.c_str(), 0, 0, 0);
        sqlite3_close(db);
    }
}

std::string getLogsJson() {
    sqlite3* db;
    std::string json = "[";
    if (sqlite3_open("speicherlog.db", &db) == SQLITE_OK) {
        sqlite3_stmt* stmt;
        const char* sql = "SELECT * FROM logs ORDER BY id DESC LIMIT 50;";
        if (sqlite3_prepare_v2(db, sql, -1, &stmt, 0) == SQLITE_OK) {
            bool first = true;
            while (sqlite3_step(stmt) == SQLITE_ROW) {
                if (!first) json += ",";
                json += "{";
                json += "\"id\":" + std::to_string(sqlite3_column_int(stmt, 0)) + ",";
                json += "\"eingesteckt_um\":\"" + std::string(reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1))) + "\",";
                json += "\"dauer_ms\":" + std::to_string(sqlite3_column_int(stmt, 2)) + ",";
                json += "\"belegter_platz\":\"" + std::string(reinterpret_cast<const char*>(sqlite3_column_text(stmt, 3))) + "\",";
                json += "\"formatierung_erfolgreich\":" + std::string(sqlite3_column_int(stmt, 4) ? "true" : "false") + ",";
                json += "\"war_schon_formatiert\":" + std::string(sqlite3_column_int(stmt, 5) ? "true" : "false");
                json += "}";
                first = false;
            }
        }
        sqlite3_finalize(stmt);
        sqlite3_close(db);
    }
    json += "]";
    return json;
}

const std::string indexHtml = R"=====(
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>Pi Laufwerk Interface</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 30px; background: #f4f4f9; }
        h1 { color: #333; }
        #statusBox { padding: 15px; background: #e3f2fd; border-left: 5px solid #2196f3; font-size: 1.2em; margin-bottom: 20px; border-radius: 4px; }
        table { width: 100%; border-collapse: collapse; background: #fff; box-shadow: 0 1px 3px rgba(0,0,0,0.1); }
        th, td { border: 1px solid #ddd; padding: 12px; text-align: left; }
        th { background: #4CAF50; color: white; }
        tr:nth-child(even) { background-color: #fafafa; }
    </style>
</head>
<body>
    <h1>Pi Laufwerk Interface</h1>
    <div id="statusBox">Status: Lade...</div>
    <table>
        <thead>
            <tr>
                <th>ID</th><th>Zeitpunkt</th><th>Dauer (ms)</th><th>Belegter Platz</th><th>Erfolgreich</th><th>Bereits formatiert</th>
            </tr>
        </thead>
        <tbody id="logsTable">
        </tbody>
    </table>
    <script>
        async function fetchData() {
            try {
                let resStatus = await fetch('/api/status');
                let jsonStatus = await resStatus.json();
                document.getElementById('statusBox').innerText = 'Status: ' + jsonStatus.status;

                let resLogs = await fetch('/api/logs');
                let jsonLogs = await resLogs.json();
                let html = '';
                jsonLogs.forEach(log => {
                    html += `<tr>
                        <td>${log.id}</td>
                        <td>${log.eingesteckt_um}</td>
                        <td>${log.dauer_ms}</td>
                        <td>${log.belegter_platz} Bytes</td>
                        <td>${log.formatierung_erfolgreich ? 'Ja' : 'Nein'}</td>
                        <td>${log.war_schon_formatiert ? 'Ja' : 'Nein'}</td>
                    </tr>`;
                });
                document.getElementById('logsTable').innerHTML = html;
            } catch (e) {
                console.error(e);
            }
        }
        setInterval(fetchData, 1500);
        fetchData();
    </script>
</body>
</html>
)=====";

static void ev_handler(struct mg_connection *c, int ev, void *ev_data) {
    if (ev == MG_EV_HTTP_MSG) {
        struct mg_http_message *hm = (struct mg_http_message *) ev_data;
        if (mg_match(hm->uri, mg_str("/api/status"), NULL)) {
            std::string statusStr;
            {
                std::lock_guard<std::mutex> lock(statusMutex);
                statusStr = currentStatus;
            }
            std::string json = "{\"status\":\"" + statusStr + "\"}";
            mg_http_reply(c, 200, "Content-Type: application/json\r\n", "%s", json.c_str());
        } else if (mg_match(hm->uri, mg_str("/api/logs"), NULL)) {
            std::string json = getLogsJson();
            mg_http_reply(c, 200, "Content-Type: application/json\r\n", "%s", json.c_str());
        } else {
            mg_http_reply(c, 200, "Content-Type: text/html; charset=utf-8\r\n", "%s", indexHtml.c_str());
        }
    }
}

void webServerThread() {
    struct mg_mgr mgr;
    mg_mgr_init(&mgr);
    mg_http_listen(&mgr, "http://0.0.0.0:3333", ev_handler, NULL);
    while (true) {
        mg_mgr_poll(&mgr, 1000);
    }
    mg_mgr_free(&mgr);
}

int main() {
    std::thread serverThread(webServerThread);
    serverThread.detach();

    const gpiod::line::offset PIN_GREEN = 4;
    const gpiod::line::offset PIN_RED = 5;

    gpiod::chip chip("/dev/gpiochip4");
    gpiod::line_settings settings;
    settings.set_direction(gpiod::line::direction::OUTPUT);
    
    gpiod::line_config line_cfg;
    line_cfg.add_line_settings({PIN_RED, PIN_GREEN}, settings);

    auto request = chip.prepare_request()
                       .set_consumer("formatter")
                       .set_line_config(line_cfg)
                       .do_request();

    auto setRed = [&](bool on) { request.set_value(PIN_RED, on ? gpiod::line::value::ACTIVE : gpiod::line::value::INACTIVE); };
    auto setGreen = [&](bool on) { request.set_value(PIN_GREEN, on ? gpiod::line::value::ACTIVE : gpiod::line::value::INACTIVE); };

    while (true) {
        setStatus("Bereit und warte auf Speichermedium...");
        setRed(false);
        setGreen(true);
        std::this_thread::sleep_for(std::chrono::seconds(2));

        std::string usbDrive = exec("lsblk -d -n -o NAME,TRAN | awk '$2==\"usb\" {print \"/dev/\"$1}' | head -n 1");

        if (!usbDrive.empty()) {
            auto startTime = std::chrono::steady_clock::now();
            setStatus("Speichermedium erkannt: " + usbDrive);
            
            setGreen(false);
            
            std::atomic<bool> isProcessing(true);
            std::thread blinkThread([&]() {
                while (isProcessing) {
                    setRed(true);  std::this_thread::sleep_for(std::chrono::milliseconds(250));
                    setRed(false); std::this_thread::sleep_for(std::chrono::milliseconds(250));
                }
            });

            std::string partition = usbDrive + "1";
            bool needsFormat = true;
            bool formatSuccess = true;
            std::string usedSpace = "unbekannt";
            std::string fsType = exec(("lsblk -n -o FSTYPE " + partition).c_str());

            if (fsType == "vfat") {
                exec("mkdir -p /mnt/usbstick");
                if (system(("mount " + partition + " /mnt/usbstick 2>/dev/null").c_str()) == 0) {
                    usedSpace = exec("df -B1 /mnt/usbstick | awk 'NR==2 {print $3}'");
                    if (usedSpace.empty()) usedSpace = "0";

                    bool isEmpty = true;
                    for (const auto& entry : fs::directory_iterator("/mnt/usbstick")) {
                        std::string filename = entry.path().filename().string();
                        if (filename != "System Volume Information" && filename != "FOUND.000") {
                            isEmpty = false;
                            break;
                        }
                    }
                    exec("umount /mnt/usbstick");
                    
                    if (isEmpty) {
                        setStatus("Medium ist bereits passend formatiert und leer.");
                        needsFormat = false;
                    }
                }
            }

            if (needsFormat) {
                setStatus("Formatiere Speichermedium...");
                system(("umount " + usbDrive + "* 2>/dev/null").c_str());
                system(("wipefs -a " + usbDrive + " >/dev/null 2>&1").c_str());
                system(("parted -s " + usbDrive + " mklabel msdos").c_str());
                system(("parted -s " + usbDrive + " mkpart primary fat32 1MiB 100%").c_str());
                
                int result = system(("mkfs.fat -F 32 " + partition).c_str());
                formatSuccess = (result == 0);
            }

            isProcessing = false;
            blinkThread.join();
            
            auto endTime = std::chrono::steady_clock::now();
            auto durationMs = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();

            logToDatabase(durationMs, usedSpace, formatSuccess, !needsFormat);
            
            setRed(false);
            setGreen(true);

            setStatus("Vorgang beendet. Bitte das Speichermedium entfernen.");
            while (true) {
                std::string checkDrive = exec(("lsblk -d -n -o NAME | grep " + usbDrive.substr(5)).c_str());
                if (checkDrive.empty()) {
                    setStatus("Speichermedium wurde erfolgreich entfernt.");
                    std::this_thread::sleep_for(std::chrono::seconds(1));
                    break; 
                }
                std::this_thread::sleep_for(std::chrono::seconds(2));
            }
        }
    }
    return 0;
}

Zwei wichtige Dinge solltest du beachten, damit du nicht dieselben Fehler machst wie ich.

Erstens: Nimm dir Zeit für jeden einzelnen Pin. Die Lötstelle muss sauber von Zinn umschlossen sein und festen Kontakt zur Platine haben. Ich war faul und habe zunächst nur zwei Pins festgelötet, damit die Leiste hält. Ich dachte, die restlichen Pins drücken schon fest genug auf die Kontakte. Drei Stunden Fehlersuche später, in denen ich mich gewundert habe, warum die LEDs nicht leuchten, stellte sich genau das als Ursache heraus.

Zweitens: Falls du eine farbig codierte Buchsenleiste verwendest, achte unbedingt auf die Ausrichtung, bevor du lötest. Ich habe meine falsch herum angelötet. Damit war die visuelle Orientierung durch die bunten Farben komplett für die Katz.

Die LEDs können wir nicht direkt an den Raspberry Pi anschließen. Wenn sie ohne Vorwiderstand betrieben werden, fließt viel zu viel Strom und die Dioden brennen nach kurzer Zeit durch. Eigentlich nutzt man für so etwas ein kleines Breadboard, aber das passt beim besten Willen nicht in unser Gehäuse. Also habe ich mich für gepflegten Eigenpfusch entschieden und alles frei Schnauze direkt zusammengelötet. Wenn du vorhast, so ein Gerät irgendwann einmal zu verkaufen: Mache es bitte niemals so! Für unseren Prototyp reicht diese Wildwest Methode aber vollkommen aus.

Kürze am besten zuerst die Beinchen der LED und des Widerstands mit dem Seitenschneider ein. Das spart wertvollen Platz im Gehäuse und sorgt für deutlich stabilere Lötstellen. Achte beim Löten unbedingt auf die Polung der LED. Das längere Beinchen ist der Pluspol, an den auch der Widerstand gelötet wird.

Für die Verkabelung nutzt du am besten ein Male to Female Kabel für den Pluspol und ein Female to Female Kabel für Minus. Beim Minusanschluss entfernst du einfach das schwarze Plastikgehäuse an einer Seite, isolierst den Draht ein kleines Stück ab und lötest diesen blanken Draht direkt an das kurze Beinchen der LED. An das verbliebene freie Ende des Widerstands wird dann die abgeknipste Seite des Male to Female Kabels gelötet.

Falls du Schrumpfschlauch daheim hast, also diesen Kunststoff den man drübermacht und erhitzt damit er sich zusammenzieht: Benutze ihn unbedingt! Damit isolierst du die Stellen sauber, verhinderst Kurzschlüsse und der Pfusch sieht am Ende sogar fast professionell aus.

Ein wichtiger Tipp noch für die Kabelwahl: Nimm am besten rot für Plus sowie grün oder schwarz für Minus. Wenn du einfach irgendwelche bunten Restkabel nimmst, verlierst du beim späteren Anstecken an den Pi schnell den Überblick darüber, wo welcher Strom fließt.