Unsere Drucker waren schon immer offen für verschiedene Modifikationen durch den Benutzer, und mit unserem GPIO Hackerboard erweitern wir diese Möglichkeiten noch weiter. Diese optionale Erweiterung hat bereits große Aufmerksamkeit bei experimentierfreudigen Anwendern erregt, die neue Möglichkeiten zur Verbesserung ihrer Original Prusa MK4/S und Prusa CORE One Setups entdecken wollen. Für diejenigen, die das Potenzial des Prusa GPIO Hackerboards noch nicht ausgelotet haben, haben wir ein Projekt vorbereitet, das es nutzt, um ein Zeitraffervideo von Ihrem 3D-Druck zu erstellen. Dieses Beispiel zeigt, was möglich ist, und wir hoffen, dass es Sie zu Ideen für Ihre eigenen Modifikationen inspiriert.

Als kurze Randbemerkung: Dieses Projekt ist so konzipiert, dass Sie High-End-Digitalkameras verwenden können, mit denen Sie die bestmögliche Bildqualität für Ihre Zeitraffer erzielen. Für diejenigen, die eine einfachere, stärker integrierte Lösung suchen, haben wir vor kurzem ein Firmware-Update für unsere Buddy3D-Kameras veröffentlicht. Dieses Update bietet die Möglichkeit, Fotos für einen Zeitraffer direkt mit der Buddy3D Kamera selbst aufzunehmen, was für viele Projekte eine perfekte Lösung sein kann. Lesen Sie unseren Artikel über dieses wichtige Update hier.

WARNUNG: Alle Änderungen und Anschlüsse erfolgen auf eigene Gefahr. Wir übernehmen keine Verantwortung für Schäden am Gerät, die z.B. durch falsche Verkabelung, unsachgemäße Handhabung oder Nichtbeachtung der Anweisungen entstehen können.

Druck-Zeitraffer mit einer Digitalkamera

In einem unserer früheren Artikel haben wir eine ausführliche Anleitung veröffentlicht, wie wir unsere schönen Zeitraffer-Videos mit einer Digitalkamera und einem speziell angefertigten Kabel erstellen, das direkt an die Hauptplatine der MK3/S- und M2.5/S-Drucker angeschlossen wird. Den Originalartikel finden Sie hier.

Bei dieser Lösung wurden die Pins auf der Hauptplatine durch G-Code-Anweisungen gesteuert, die einen Spannungsausgang an ihnen aktivierten. Das Spannungssignal aktivierte dann eine Schaltung im Kabel und löste den Verschluss der Kamera aus. Diese Methode funktionierte zwar, war aber recht kompliziert, da die Kabel von DuPont direkt an die Pins der Hauptplatine des Druckers angeschlossen werden mussten, was das Risiko einer falschen Verdrahtung mit sich brachte. Das GPIO Hackerboard bietet eine ähnliche, aber elegantere Lösung. Es wird über einen einfachen I2C-Anschluss an die Hauptplatine eines MK4/S- oder CORE One-Druckers angeschlossen, und die G-Code-Befehle aktivieren einen der acht E/A-Pins des Hackerboards, so dass Sie ganz einfach externe Geräte steuern können.

Um 3D-Druck-Zeitraffer zu erstellen, können Sie sowohl kabelgebundene als auch kabellose Fernauslöser verwenden, je nachdem, was Ihre Kamera unterstützt. Die bevorzugte Lösung ist jedoch ein kabelloser Fernauslöser, da er vollständig von der Elektronik und der Stromversorgung des Druckers isoliert ist und Ihre Kamera so jederzeit sicher ist. Wir zeigen Ihnen beide Lösungen, damit Sie diejenige wählen können, die Ihren Bedürfnissen am besten entspricht.

Beachten Sie: Schalten Sie Ihren Drucker immer aus, bevor Sie das GPIO Hackerboard anschließen, um mögliche Schäden am GPIO Hackerboard oder am Drucker zu vermeiden!

Kabelgebundener Fernauslöser

Schauen wir uns zunächst an, wie Sie eine Kamera mit einem Kabel an das GPIO Hackerboard anschließen. Es ist wichtig zu wissen, dass verschiedene Kameras unterschiedliche Methoden zum Anschließen und Auslösen eines Fernauslösers erfordern. Einige benötigen zum Beispiel eine elektrische Schaltung mit bestimmten Widerständen (wie die, die wir für unsere Panasonic Lumix DC-GH5 in einem vorherigen Artikel gebaut haben) oder verwenden spezielle Anschlüsse. Andere hingegen benötigen einfach nur eine Überbrückung von Kontakten an einem Standard-2,5-mm-Klinkenkabel, um einen Schnappschuss auszulösen.

Für diese Anleitung werden wir uns auf diese einfache Lösung konzentrieren und ein Kabel mit einer 4-poligen 2,5-mm-Klinkenbuchse an beiden Enden verwenden. Bei diesem Ansatz ist kein Löten erforderlich, was den gesamten Prozess vereinfacht und es Ihnen ermöglicht, die Schaltung bei Bedarf einfach anzuschließen und zu trennen.

Schließen Sie zunächst das GPIO Hackerboard an Ihren Drucker an (vergessen Sie nicht, ihn vorher auszuschalten). Dann stecken Sie ein Ende des Klinkenkabels in das Hackerboard und das andere Ende in Ihre Kamera. Sie können den Drucker jetzt wieder einschalten.

Als Nächstes prüfen wir, welche Segmente des 2,5-mm-Klinkensteckers wir überbrücken müssen, damit die Kamera ein Bild aufnimmt. Unten finden Sie ein Diagramm, das veranschaulicht, welche Verbindungen den Autofokus und welche den Schnappschuss auslösen (dies ist spezifisch für unser Kameramodell). In diesem Fall überbrücken wir zum Auslösen des Schnappschusses das erste (0) und das letzte (GND) Segment des 2,5-mm-Klinkensteckers. Dies wird durch ein paar einfache G-Code-Anweisungen gesteuert, die in PrusaSlicer eingefügt werden.

Bevor wir mit PrusaSlicer fortfahren, lassen Sie uns schnell die Kamera einrichten, um einen guten Blick auf das Druckbett zu erhalten und die richtigen Kameraeinstellungen, einschließlich des Fokus, sicherzustellen. Nachdem Sie die Einstellungen vorgenommen haben, schalten Sie die Kamera in den manuellen Fokusmodus.

Öffnen Sie PrusaSlicer, wählen Sie Ihren Drucker und importieren Sie das Modell, das Sie drucken wollen. Navigieren Sie dann im oberen Menü zur Registerkarte Drucker und wählen Sie im Menü auf der linken Seite die Option „Benutzerdefinierter G-Code“. Wenn Sie diese Option nicht sehen, schalten Sie PrusaSlicer über das Dropdown-Menü in der oberen rechten Ecke des Bildschirms neben dem Benutzersymbol in den Expertenmodus.

Hier finden Sie G-Code-Befehle, die bei jedem Druck ausgeführt werden, unabhängig vom gedruckten Modell, den Einstellungen usw. Dazu gehören Anweisungen, die vor dem Start eines Drucks, nach dessen Beendigung oder vor/nach jedem Wechsel der Schicht usw. ausgeführt werden. Wir werden uns auf die Abschnitte Start G-code und Nach Schichtwechsel G-code konzentrieren. Im Abschnitt Start G-code legen wir Pin 0 als Ausgang fest, indem wir diese Anweisung ganz am Ende des Abschnitts platzieren (Text nach einem Semikolon ist ein Kommentar und beeinflusst den Code nicht):

; Pin 0 als Ausgang festlegen

M262 P0 B0

Als nächstes lösen wir im Abschnitt Nach Schichtwechsel G-Code die eigentliche Snapshot-Sequenz aus. Das bedeutet, dass wir jedes Mal, wenn eine gedruckte Schicht fertig ist, den Druckkopf aus dem Weg bewegen, um eine klare Aufnahme zu gewährleisten, und ein Foto machen. Der Druckkopf wartet einen Moment und kehrt dann in seine Ausgangsposition zurück. Der Druck wird bis zum Wechsel der nächsten Schicht fortgesetzt. Auch hier platzieren wir diese Anweisungen ganz am Ende des Abschnitts:

G1 X160 Y160 F{travel_speed*60} ;Vom Druck wegbewegen
G4 S0 ;Warten bis die Bewegung beendet ist
G4 P150 ;150ms warten, um dem Bett Zeit zu geben, richtig anzuhalten
M265 P0 ;Den Pin-Status auf 1 setzen, um den Shutter auszulösen
M265 P0 ;Den Pin-Status zurück auf 0 setzen
G4 P250 ;250ms warten, um der Kamera Zeit zu geben, die Aufnahme zu beenden

Sie können diese Konfiguration über das Speichersymbol im oberen Menü speichern, so dass Sie leicht zwischen normalen und Zeitraffer-Druckprofilen wechseln können.

Jetzt können Sie zur Registerkarte Druckplatte zurückkehren, auf die Schaltfläche Slicen klicken und den fertigen G-Code an Ihren Drucker senden. Nachdem der Druckvorgang begonnen hat, wird die Kamera nach jeder gedruckten Schicht ausgelöst, so dass Sie ein klares, stabilisiertes Bild von Ihrem Druckvorgang erhalten. Mit nur ein paar Zeilen G-Code können Sie wunderschöne Zeitrafferaufnahmen Schicht für Schicht erstellen!

Wenn alles geklappt hat, sollten Sie jetzt viele tolle Fotos des laufenden Drucks haben. Jetzt müssen wir sie in ein Zeitraffervideo umwandeln. Dazu verwenden wir die hervorragende Videobearbeitungssoftware DaVinci Resolve, die Sie hier kostenlos herunterladen können.

Erstellen eines Zeitraffervideos mit DaVinci Resolve

Installieren und öffnen Sie zunächst DaVinci Resolve und erstellen Sie ein neues Projekt. Bevor Sie irgendetwas anderes tun, navigieren Sie zur Registerkarte Media, die das erste Symbol im Menü am unteren Rand des Bildschirms ist. Klicken Sie dort im oberen Menü auf die Schaltfläche mit den drei Punkten und stellen Sie sicher, dass die Option ‚Frame Display Mode‘ auf ‚Sequence‘ eingestellt ist. Mit dieser Einstellung wird Resolve angewiesen, alle importierten Fotos zu einem einzigen Videoclip zusammenzufassen, anstatt Hunderte (oder sogar Tausende, bei längeren Zeitraffern) von Einzelbildern zu verwenden.

Wechseln Sie nun auf die Seite Bearbeiten. Um Ihre Fotos zu importieren, suchen Sie sie in ihrem Ordner auf Ihrem Computer und markieren Sie sie alle. Wenn Sie alle Dateien ausgewählt haben, ziehen Sie sie in den Master-Bereich auf der linken Seite des Bildschirms und legen sie dort ab. Dadurch werden automatisch ein oder mehrere Sequenzclips aus allen Bildern erstellt. Ziehen Sie nun den/die Clip(s) in Ihre Timeline. Sie können eine Vorschau des erzeugten Zeitraffers anzeigen, indem Sie auf die Schaltfläche Abspielen klicken oder die rote Linie über den Konstruktionsverlauf ziehen. Sie können auch die Framerate ändern und verschiedene Nachbearbeitungseffekte auf Ihr Zeitraffervideo anwenden, wie z.B. Farbkorrektur, Bildstabilisierung und mehr.

Ihr Ergebnis kann etwa so aussehen:

Sie können die Werte in den G-Code-Anweisungen, wie z.B. die Position des Druckkopfs oder die Wartezeiten, an Ihre Bedürfnisse anpassen. Denken Sie jedoch daran, dass die längere Bewegungszeit das Risiko erhöht, dass Filament aus der heißen Düse austritt. Dies kann möglicherweise zu Druckartefakten oder Fadenbildung führen. Um dieses Problem zu minimieren, verwenden Sie gut getrocknetes Filament und vermeiden Sie es, übermäßig lange Verfahrwege für den Druckkopf einzustellen.

Da Sie nun wissen, wie Sie ein Zeitraffervideo mit einer kabelgebundenen Kamera erstellen können, sehen wir uns nun einige andere Optionen für die Aufnahme der Fotos an. Wir beginnen mit einem drahtlosen Fernauslöser für Ihre Digitalkamera und gehen dann zu einer etwas fortgeschritteneren Methode über, bei der Sie Ihr Smartphone verwenden.

Kabelloser Fernauslöser

Die drahtlose Lösung erfordert ein wenig Lötarbeit, ist aber sehr einfach und die Einrichtung des G-Codes ist identisch mit dem vorherigen Beispiel.

Wir verwenden Sony Alpha-Kameras, daher haben wir einen preiswerten drahtlosen IR-Fernauslöser von Sony gekauft. In der Regel können Sie markenspezifische oder universelle Versionen solcher Fernauslöser, die für mehrere Marken geeignet sind, für nur ein paar Euro online bestellen.

Demontieren Sie den Auslöser, um an die interne Platine zu gelangen und das Kontaktpaar zu identifizieren, das überbrückt wird, wenn die Auslösetaste gedrückt wird. Während einige Tasten mehrere Positionen für Fokus und Auslöser haben, löst dieser spezielle Fernauslöser nur den Schnappschuss aus. Sie können die korrekte Verdrahtung herausfinden, indem Sie die Platine betrachten oder das Datenblatt zu Rate ziehen.

Für die Verbindung zwischen dem drahtlosen Fernauslöser und dem GPIO Hackerboard verwenden wir wieder ein 4-poliges 2,5-mm-Klinkenkabel, allerdings in einer anderen Konfiguration. Statt eines Klinkensteckers an beiden Enden benötigen wir an einem Ende freiliegende Drähte, die an die Platine des Fernauslösers gelötet werden. Sie haben zwei Möglichkeiten, dieses Kabel zu bekommen: Entweder Sie kaufen ein vorgefertigtes Kabel oder Sie machen es selbst, indem Sie ein normales Klinke-zu-Klinke-Kabel zuschneiden und ein Ende vorsichtig abisolieren, um die internen Drähte freizulegen. Verwenden Sie ein Multimeter, um festzustellen, welche der vier Drähte mit den richtigen Segmenten der Buchse übereinstimmen. Wir verwenden dieselben beiden Kontakte wie in der Abbildung im vorherigen Abschnitt – das erste (0) und das letzte (GND) Segment des Klinkensteckers. Sobald Sie die richtigen zwei Drähte identifiziert haben, löten Sie sie an die Kontakte der Taste auf der Platine des Fernauslösers. Schneiden Sie die verbleibenden zwei Drähte ab und bauen Sie das Gehäuse des Fernauslösers wieder zusammen.

Schließen Sie nun das GPIO Hackerboard an den Drucker an und schalten Sie ihn ein. Stecken Sie dann den 2,5-mm-Klinkenstecker in die Buchse auf dem GPIO-Hackerboard, richten Sie die Funkfernbedienung auf Ihre Kamera und starten Sie den Druck mit der vorbereiteten Zeitraffer-G-Code-Sequenz. Genau wie im vorherigen Beispiel sollte der Drucker bei jedem Schichtwechsel anhalten und ein (drahtloses) Signal an die Kamera senden, um einen Schnappschuss zu machen.

Für diejenigen, die eine visuelle Anleitung zum Löten und zur Verwendung des drahtlosen Fernauslösers und des GPIO Hackerboards suchen, hat Martin Zeman, ein Mitglied der 3D-Druck-Community, ein großartiges Video zusammengestellt, das den gesamten Prozess zeigt:

Fotos mit einem Smartphone über Bluetooth und ESP32 aufnehmen

Möchten Sie bei diesem Projekt noch einen Schritt weiter gehen? Sie können Ihr Smartphone anstelle einer Digitalkamera verwenden. Die Bildqualität ist mehr als gut genug, um ein großartiges Zeitraffervideo zu erstellen. Mit dem GPIO Hackerboard und einem kleinen ESP32-Board mit Bluetooth-Konnektivität können Sie Ihren eigenen drahtlosen Fernauslöser für Ihr Telefon bauen.

Um diesen zu bauen, müssen Sie nicht nur löten, sondern auch ein bisschen programmieren. Die Einrichtung ist etwas komplexer, da Sie einen speziellen Code erstellen und auf das ESP32-Board hochladen müssen. Das Board verarbeitet das gleiche Signal vom GPIO Hackerboard, wie im vorherigen Beispiel. Anstatt jedoch die Kontakte der Digitalkamera auszulösen, sendet es über Bluetooth einen Befehl an Ihr Telefon, der das Drücken der Lautstärketaste simuliert, die normalerweise als Auslöser der Kamera dient.

Zunächst überbrücken Sie auf dem GPIO-Hackerboard die JP7-Kontakte, indem Sie sie anlöten, um den integrierten Pull-up-Widerstand zu aktivieren. Dann löten Sie die Verbindungen zwischen den Boards: Verbinden Sie den GND-Kontakt des Hackerboards mit einem GND-Pin auf dem ESP32-Board und den Kontakt OUT 7 mit Pin D3 (GPIO5) auf dem ESP32.

Lassen Sie uns mit der Software fortfahren. Unten finden Sie das Code-Beispiel, das wir verwendet haben, um unser ESP32-Board zum Laufen zu bringen. Betrachten Sie es als inspirierenden Ausgangspunkt für Ihr eigenes Projekt.

Bitte beachten Sie:Dieser Code wird ohne Garantie und ohne Mängelgewähr bereitgestellt. Sie müssen ihn wahrscheinlich anpassen, damit er mit Ihrer speziellen Hardware funktioniert.

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLEAdvertising.h>
#include <BLEHIDDevice.h>
#include <BLESecurity.h>
// Einfügen der erforderlichen ESP-IDF-Header
#include "esp_gatt_defs.h"
#include "esp_bt_defs.h"
#include "esp_bt_main.h"

// --- Konstanten ---
const char* DEVICE_NAME = "Prusa-Timelapse-Trigger";
const uint16_t APPEARANCE_CONSUMER_CONTROL = 384;

// Consumer Control Report Bits
const uint16_t VOLUME_UP_BIT = (1 << 0); // 0x0001

// --- GPIO Trigger Pin Konfiguration ---
const int TRIGGER_PIN = 5; // GPIO5 verwenden (Pin D5 auf XIAO ESP32-C3)
int lastPinState = HIGH; // Annehmen, dass der Pin aufgrund von INPUT_PULLUP mit HIGH beginnt
int currentPinState = HIGH;
unsigned long lastDebounceTime = 0; // Timer für Entprellung
const unsigned long debounceDelay = 50; // Entprellungszeit in Millisekunden

// Abkühlungsvariablen (wiederhergestellt)
unsigned long lastTriggerTime = 0;
const unsigned long triggerCooldown = 500; // Minimum ms zwischen Triggern


// --- BLE Variablen ---
BLEHIDDevice* pHid;
BLECharacteristic* pInputConsumer;
bool deviceConnected = false;

// --- HID Report Map ---
// (Wie zuvor)
static const uint8_t hidReportMap[] = {
0x05, 0x0C, 0x09, 0x01, 0xA1, 0x01, 0x85, 0x01, 0x15, 0x00, 0x25, 0x01,
0x75, 0x01, 0x95, 0x10, 0x09, 0xE9, 0x09, 0xEA, 0x09, 0xE2, 0x09, 0xB0,
0x09, 0xB1, 0x09, 0xB7, 0x09, 0xB3, 0x09, 0xB4, 0x09, 0xB5, 0x09, 0xB6,
0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00, 0x09, 0x00,
0x81, 0x02, 0xC0
};


// --- Connection Callback Class ---
// (Bleibt unverändert)
class MyServerCallbacks: public BLEServerCallbacks {
void onConnect(BLEServer* pServer) { deviceConnected = true; Serial.println("----> Device Connected <----"); }
void onDisconnect(BLEServer* pServer) { deviceConnected = false; Serial.println("----> Device Disconnected <----"); BLEDevice::startAdvertising(); Serial.println("Advertising Restarted (HID)"); }
};

// --- Security Callback Class ---
// (Bleibt unverändert - vereinfachte Version)
class MySecurityCallbacks : public BLESecurityCallbacks {
uint32_t onPassKeyRequest(){ Serial.println("PassKeyRequest"); return 123456; }
void onPassKeyNotify(uint32_t pass_key){ Serial.print("OnPassKeyNotify: "); Serial.println(pass_key); }
bool onConfirmPIN(uint32_t pass_key){ Serial.print("OnConfirmPIN: "); Serial.println(pass_key); return true; }
bool onSecurityRequest(){ Serial.println("OnSecurityRequest"); return true; }
void onAuthenticationComplete(esp_ble_auth_cmpl_t cmpl){ Serial.println("OnAuthenticationComplete event received."); }
};


// --- Setup Funktion ---
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("Starten des Single-Pin-Trigger-Tests (D5)...");

// *** Konfiguriere NUR den Trigger-GPIO-Pin (D5/GPIO5) ***
pinMode(TRIGGER_PIN, INPUT_PULLUP);
lastPinState = digitalRead(TRIGGER_PIN); // Anfangszustand lesen
currentPinState = lastPinState; // Angenommen der Anfangszustand ist stabil
Serial.print("Monitore Trigger Pin D");
Serial.print(TRIGGER_PIN); // Prints 5 now
Serial.print("(GPIO");
Serial.print(TRIGGER_PIN);
Serial.println(") konfiguriert als INPUT_PULLUP.");

// --- Vollständiges BLE-Setup wiederherstellen ---
BLEDevice::init(DEVICE_NAME);
BLEDevice::setSecurityCallbacks(new MySecurityCallbacks());
Serial.println("BLE Initialisiert & Security Callbacks gesetzt");
BLEServer *pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());
Serial.println("BLE-Server Erstellt mit Connection Callbacks");
pHid = new BLEHIDDevice(pServer);
Serial.println("BLE HID Device erstellt");
pInputConsumer = pHid->inputReport(1);
if (pInputConsumer == nullptr) { Serial.println("FEHLER: Erstellung fehlgeschlagen InputConsumer characteristic!"); while(1) delay(1000); }
Serial.println("Consumer Control Input Characteristic fertig");
pHid->reportMap((uint8_t*)hidReportMap, sizeof(hidReportMap));
pHid->hidInfo(0x00, 0x01);
pHid->pnp(0x02, 0x1234, 0x5678, 0x0110);
Serial.println("HID Metadata Set");
BLESecurity *pSecurity = new BLESecurity();
pSecurity->setCapability(ESP_IO_CAP_NONE);
pSecurity->setAuthenticationMode(ESP_LE_AUTH_REQ_SC_BOND);
pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
pSecurity->setRespEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
Serial.println("BLE Security Konfiguriert für Bonding");
pHid->startServices();
Serial.println("HID Service gestartet");
BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
pAdvertising->setAppearance(APPEARANCE_CONSUMER_CONTROL);
pAdvertising->addServiceUUID(pHid->hidService()->getUUID());
pAdvertising->setScanResponse(true);
pAdvertising->setMinPreferred(0x06);
pAdvertising->setMaxPreferred(0x12);
BLEDevice::startAdvertising();
Serial.println("HID Advertising Gestartet - Bereit für GPIO-Trigger an D5");
Serial.println("------------------------------------");
}

// --- Sende Consumer Control Report ---
// (Funktion bleibt unverändert)
void send_consumer_report(uint16_t buttons) {
if (!deviceConnected) { Serial.println("Trigger received but not connected to phone."); return; }
if (pInputConsumer == nullptr) { Serial.println("ERROR: InputConsumer characteristic is NULL!"); return; }
uint8_t report[2];
report[0] = buttons & 0xFF; report[1] = (buttons >> 8) & 0xFF;
pInputConsumer->setValue(report, sizeof(report)); pInputConsumer->notify();
Serial.print("Sent Report: 0x"); Serial.print(buttons, HEX);
delay(20);
report[0] = 0; report[1] = 0;
pInputConsumer->setValue(report, sizeof(report)); pInputConsumer->notify();
Serial.println(" -> Released");
}


// --- Loop Funktion (Single Pin Check) ---
void loop() {
// *** NUR lesen den definierten Status des Triggerpins (D5/GPIO5) ***
int reading = digitalRead(TRIGGER_PIN);

// Prüfen Sie, ob sich der Zustand des Pins geändert hat
if (reading != lastPinState) {
lastDebounceTime = millis(); // Entprellungs-Timer zurücksetzen
}

// Prüfen, ob die Entprellungszeit abgelaufen ist
if ((millis() - lastDebounceTime) > debounceDelay) {
// Wenn der Zustand des Pins stabil ist und sich von dem zuletzt bestaetigten Zustand unterscheidet
if (reading != currentPinState) {
currentPinState = reading; // Aktualisieren des aktuellen bestaetigten Status

// Wir lösen gezielt aus, wenn der Pin auf LOW
if (currentPinState == LOW) {
// Pruefe Trigger Cooldown
if (millis() - lastTriggerTime > triggerCooldown) {
Serial.print(">>> Triggere Aktion fuer Pin D");
Serial.print(TRIGGER_PIN); // Sollte 5 ausgeben
Serial.println(" (LOW Status bestaetigt)");
send_consumer_report(VOLUME_UP_BIT); // Sende Volume Up Kommando
lastTriggerTime = millis(); // Cooldown Timer zuruecksetzen
} else {
Serial.print("Trigger Pin D"); Serial.print(TRIGGER_PIN); Serial.println(" wurde LOW, aber in Cooldown.");
}
} else {
// Optional: Loggen wenn Pin auf HIGH zurueck
Serial.print("Trigger Pin D"); Serial.print(TRIGGER_PIN); Serial.println(" wurde HIGH (Idle)");
}
}
}
// lastPinState für die naechste Iteration der Schleife aktualisieren
lastPinState = reading;

delay(5); // Kleine Verzögerung
}

Wir müssen diesen Code mit Hilfe der Arduino IDE Software auf das ESP32 Board hochladen. Die Menüstruktur und die Namen der Elemente können je nach Anwendungsversion oder der von Ihnen verwendeten Plattform variieren.

Schließen Sie zunächst das ESP32-Board über USB an den Computer an, starten Sie die Arduino IDE und installieren Sie das ESP32-Board-Paket, indem Sie zu File -> Preferences navigieren und die folgende URL in das Feld „Additional Boards Manager URLs“ einfügen: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json. Gehen Sie dann zu Tools -> Board -> Boards Manager, suchen Sie nach „ESP32“, wählen Sie die neueste Version des ESP32 und installieren Sie sie. Wählen Sie nun Ihr Board-Modell unter Tools -> Board -> ESP32. Und schließlich öffnen Sie Tools -> Port und wählen den korrekten Namen der seriellen Schnittstelle des angeschlossenen Boards.

Nun können Sie den Code auf Ihr ESP32 hochladen. Löschen Sie den generierten Code in der Arduino IDE und fügen Sie den Code von oben ein. Klicken Sie auf die Schaltfläche Hochladen (Pfeil) und warten Sie, bis die Arduino IDE den Code kompiliert und auf das Board hochgeladen hat.

Wenn alles richtig gemacht wurde, versuchen Sie, nach dem Bluetooth-Gerät mit dem Namen „Prusa-Timelapse-Trigger“ (oder einem anderen Namen, falls Sie ihn im Code geändert haben) zu suchen und sich mit ihm zu verbinden. Um die Statusmeldungen der seriellen Kommunikation zu überprüfen, gehen Sie zu Tools -> Serial Monitor.

Sie können nun den Trigger testen, indem Sie das Signal vom Hackerboard simulieren. Verwenden Sie eine Pinzette oder einen kleinen Draht, um den Eingangspin des ESP32 (D3/GPIO5) kurz mit einem GND Pin zu verbinden. Sie sollten sehen, dass sich die Lautstärke auf Ihrem Telefon ändert. Wenn das der Fall ist, können Sie loslegen. Trennen Sie den ESP32 von Ihrem Computer und schalten Sie ihn mit einem Standard-USB-C-Netzteil ein. Jetzt können Sie das GPIO Hackerboard an Ihren Drucker anschließen. Vergessen Sie nicht, den Drucker auszuschalten, bevor Sie das Hackerboard anschließen!

Wir müssen den G-Code in PrusaSlicer leicht modifizieren, damit er den Ausgang OUT7 statt OUT0 auslöst. Dazu ändern wir einfach P0 in P7 in den Abschnitten Start G-code und Nach Schichtwechsel G-code. Jetzt, wenn Sie den Druck starten, signalisiert das GPIO Hackerboard jedes Mal, wenn eine Schicht gewechselt wird, dem ESP32, der dann einen Befehl sendet, um die Lautstärke auf Ihrem Telefon zu ändern. Wenn Ihre Kamera-App aktiv ist, wird dadurch der Auslöser betätigt und ein Foto gemacht.

Und das war’s! Dies ist nur einer von vielen möglichen Anwendungsfällen für das GPIO Hackerboard. Fühlen Sie sich frei, diese Lösungen zu modifizieren und zu verbessern. Wir freuen uns auf Ihre Ideen, wie Sie dieses kleine und clevere Modul einsetzen können. Eine ausführliche Anleitung für das GPIO Board finden Sie auf unserer Hilfe.

Viel Spaß beim Drucken!