Naše tiskárny jsou známé svou otevřeností nejrůznějším uživatelským úpravám, a s naším přídavným modulem GPIO Hackerboard jsou jejich možnosti ještě větší. Tento volitelný doplněk si již získal velkou pozornost uživatelů, kteří rádi experimentují a hledají nové možnosti, jak dále vylepšit své tiskárny Original Prusa MK4/S a Prusa CORE One. A pro ty, kteří ještě nestačili prozkoumat, jaké možnosti vám Prusa GPIO Hackerboard dokáže nabídnout, jsme připravili jednoduchý projekt, který jej využívá pro vytváření časosběrného videa z 3D tisku. Doufáme, že vás inspiruje k vymýšlení vlastních modifikací.

Malá poznámka na okraj: tento projekt je navržen tak, abyste pro vytváření časosběrného videa mohli využít profesionální fotografická zařízení a dosáhli tak té nejlepší výsledné kvality obrazu. Pokud však hledáte nějaké jednodušší řešení, připomínáme, že naše kamery Buddy3D nedávno obdržely významný firmwarový update. Ten vám umožňuje vytvářet snímky pro časosběrná videa přímo v kameře Buddy3D, což může být ideální a nejjednodušší řešení pro velké množství projektů. Více informací o této významné aktualizaci naleznete v našem článku.

UPOZORNĚNÍ: Všechny úpravy a zapojení provádíte na vlastní nebezpečí. Neneseme žádnou odpovědnost za poškození jakéhokoli zařízení, ke kterému by mohlo dojít například v důsledku nesprávného zapojení, manipulace nebo nedodržení pokynů.

Časosběrné video s využitím (bez)zrcadlovky

V jednom z našich předchozích článků jsme vám přinesli detailní popis toho, jak vytváříme naše nádherná časosběrná videa. Použili jsme k tomu digitální fotoaparát a vlastnoručně vyrobený kabel, který jsme zapojili přímo do základní desky tiskárny MK3/S či MK2.5/S. Článek si můžete přečíst zde.

V tomto projektu jsme ovládali piny na základní desce pomocí G-code instrukcí, které na piny přiváděly napětí. Tím se následně aktivoval obvod v našem kabelu a vyslal signál do fotoaparátu, který pořídil snímek. Ačkoli tato metoda fungovala velice dobře, byla poměrně složitá, a jelikož bylo potřeba připojovat DuPont kabely přímo na piny základní desky, mohlo lehce dojít ke špatnému zapojení. S pomocí GPIO Hackerboardu můžete využít podobné, ale mnohem elegantnější řešení. Hackerboard se připojuje na základní desku tiskáren MK4/S či CORE One pomocí konektoru I2C, a G-code instrukce pak aktivují jeden z osmi dostupných I/O pinů. Díky tomu můžete jednoduše ovládat externí zařízení.

Pro vytváření časosběrných videí 3D tisku můžete využít jak kabelovou, tak bezdrátovou vzdálenou spoušť, podle toho, co váš fotoaparát podporuje. Ideálním řešením je použití bezdrátové spouště, jelikož je pak váš fotoaparát zcela oddělen od elektroniky tiskárny, a je tak plně chráněn proti případnému poškození. Ukážeme vám nicméně obě řešení, abyste si mohli vybrat to, které vám vyhovuje nejlépe.

Nezapomeňte: Před připojením GPIO Hackerboardu vždy vypněte tiskárnu, abyste předešli možnému poškození GPIO Hackerboardu či tiskárny!

Kabelová dálková spoušť

Jako první si ukážeme propojení fotoaparátu a GPIO Hackerboardu pomocí kabelu. Nejprve je však důležité zmínit, že různé fotoaparáty využívají různé způsoby připojení a aktivování dálkové spouště. Některé mohou například vyžadovat speciální elektrický obvod s předepsanými rezistory (jako ten, který jsme použili u našeho Panasonic Lumix DC-GH5 ve výše zmíněném článku), nebo využívat specifické konektory. Jiným fotoaparátům pak může k pořízení snímku stačit obyčejné propojení kontaktů standardního konektoru jack 2,5 mm.

Právě na poslední jmenované řešení se v našem návodu podíváme, a využijeme kabel s 4-pólovým konektorem 2,5 mm jack na obou stranách. Díky tomu se vyhneme jakémukoli pájení, což nám celý proces značně zjednoduší, a navíc budete moci celý obvod kdykoli odpojit a připojit zpět dle potřeby.

Jako první připojte GPIO Hackerboard k vaší tiskárně (nezapomeňte jí předtím vypnout). Poté zapojte jeden konec kabelu s konektorem 2,5 mm jack do Hackerboardu a druhý do zdířky ve fotoaparátu. Tiskárnu můžete nyní opětovně zapnout.

Nyní je potřeba zjistit, které segmenty konektoru 2,5 mm jack je potřeba propojit, abychom fotoaparátu řekli, že má vyfotit snímek. Na obrázku níže naleznete schéma, ilustrující, které propojení na našem fotoaparátu aktivuje funkci autofocus, a které pořídí snímek. V tomto případě propojíme první (0) a poslední (GND / Zem) segment konektoru 2,5 mm jack. Tohle vše provedeme pomocí několika řádků jednoduchých G-code instrukcí, vložených do PrusaSliceru.

Ještě než se dostaneme k psaní instrukcí, v rychlosti si nastavíme fotoaparát tak, aby měl dobrý výhled na tiskovou plochu a správně zaostřený obraz. Po dokončení umístění a nastavení přepněte fotoaparát do režimu manuálního ostření.

Otevřete si PrusaSlicer, vyberte správnou tiskárnu a importujte model, který budete tisknout. Poté přejděte do záložky Tiskárny v horním menu, a zde vyberte položku Vlastní G-code z levého menu. Pokud takovou položku nevidíte, přepněte si PrusaSlicer do Expertního režimu pomocí rozbalovací nabídky v pravé horní části obrazovky, hned vedle uživatelské ikonky.

Zde naleznete různé G-code příkazy, které se vykonávají při každém tisku, nezávisle na tisknutém modelu a nastavení. Patří sem například instrukce, které se provedou na začátku, respektive na konci každého tisku, před či po změně každé vrstvy a tak dále. My se nyní zaměříme na sekce Začátek G-code a G-code po změně vrstvy. V sekci Začátek G-code nastavíme Pin 0 jako výstup, vložením následující instrukce na úplný konec sekce (text za středníkem je komentář a nemá vliv na funkci kódu).

; Nastaveni Pinu 0 jako vystupu
M262 P0 B0

Následně, do sekce G-code po změně vrstvy vložíme sekvenci samotného snímání fotoaparátu. Fungovat to bude tak, že pokaždé, když dojde k dokončení tisku vrstvy, posuneme tiskovou hlavu stranou, aby nebránila výhledu fotoaparátu, a pořídíme snímek. Tisková hlava chvilku počká na místě a poté se vrátí zpět na svou původní pozici. Tisk pak pokračuje až do další změny vrstvy. Veškeré nové instrukce opětovně vložíme na úplný konec sekce:

G1 X160 Y160 F{travel_speed*60} ;Odjezd hlavy od tisku
G4 S0 ;Cekani na dokonceni pohybu
G4 P150 ;Cekani 150 ms na ustaleni pohybu podlozky
M265 P0 ;Prepnuti stavu pinu do 1 pro aktivaci spouste
M265 P0 ;Prepnuti stavu pinu zpet do 0
G4 P250 ;Cekani 250 ms na radne dokonceni snimani

Celou konfiguraci si můžete uložit pomocí ukládací ikonky v horním menu, díky čemuž lze kdykoli jednoduše přepínat mezi normálními tiskovými profily a profily s časosběrnou sekvencí.

Nyní se můžete přepnout zpět do záložky Podložka, kliknout na tlačítko Slicovat a odeslat hotový G-code do tiskárny. Jakmile se tisková úloha spustí, fotoaparát bude při každé změně vrstvy pravidelně pořizovat kvalitní a konzistentní snímky probíhajícího tisku. S pouhými několika řádky G-code tak nyní můžete vytvářet krásná časosběrná videa, se zachycením každé jednotlivé vrstvy!

Pokud vám vše správně funguje, měli byste nyní mít spoustu krásných fotografií probíhajícího tisku. Zbývá je tedy jen přeměnit na výsledné časosběrné video. K tomu použijeme skvělý software pro editaci videa, DaVinci Resolve, který si můžete zdarma stáhnout zde.

Vytvoření časosběrného videa v DaVinci Resolve

Nejprve si DaVinci Resolve stáhněte, nainstalujte a vytvořte v něm nový projekt. Poté přepněte do záložky Media, což je úplně první ikonka ve spodním menu. Zde v horní části menu klikněte na tlačítko se třemi tečkami a ujistěte se, že možnost ‘Frame Display Mode’ je nastavena na ‘Sequence’. Toto nastavení zajistí, že všechny importované fotografie se sjednotí do videoklipu. Kdybyste tuto funkci neměli zapnutou, vložené fotografie, kterých mohou být stovky až tisíce, dle délky tisku, by se do projektu importovaly jednotlivě.

Přepněte se do záložky Edit. Zde můžete importovat vaše fotografie tak, že je ve složce v počítači všechny označíte a následně přetáhnete přímo do okna Master na levé straně obrazovky. Pokud máte vše správně nastavené, vytvoří se zde z fotek jeden, či více sekvenčních klipů, které můžete rovnou přetáhnout do časové osy níže. Výsledné časosběrné video si zde můžete prohlédnout stisknutím tlačítka Play, nebo tažením červené linky po časové ose. Můžete zde také změnit snímkovou frekvenci videa, nebo přidat různé post-process efekty, jako je úprava barev, stabilizace obrazu a tak podobně.

Výsledek vašeho snažení pak může vypadat třeba následovně:

Jednotlivé hodnoty G-code instrukcí, jako třeba pozici tiskové hlavy, si můžete doladit dle potřeby. Nezapomeňte však na to, že čím delší trasu musí tisková hlava urazit, tím větší je riziko, že z trysky bude vytékat roztavený filament. To může následně vytvářet tiskové artefakty nebo stringování. Abyste výskyt těchto problémů minimalizovali, používejte řádně vysušený filament a nenastavujte zbytečně dlouhé přejezdy tiskové hlavy.

Nyní jste si úspěšně vytvořili časosběrné video pomocí fotoaparátu a kabelové spouště! Pojďme se však podívat ještě na další řešení, jak můžete snímky pořizovat. Začneme s bezdrátovou verzí dálkové spouště, kde opět využijete digitální fotoaparát, a poté si ukážeme ještě jeden lehce pokročilejší způsob, při kterém přijde řada na váš chytrý telefon.

Bezdrátová dálková spoušť

Bezdrátová varianta dálkové spouště po vás bude vyžadovat trochu pájení, které však bude velice jednoduché. Nastavení G-code pak bude identické jako v předchozím příkladu.

Jelikož využíváme fotoaparáty Sony Alpha, pořídili jsme levnou bezdrátovou spoušť Sony, která využívá infračervený (IR) signál. Podobné varianty bezdrátových spouští, ať už univerzálních či určených pro jednu značku, můžete na internetu pořídit za pár korun.

Spoušť rozebereme, abychom se dostali k vnitřnímu tištěnému spoji, a zjistíme, které kontakty se propojí, když se stiskne tlačítko pro pořízení snímku. Některá tlačítka mohou mít i více pozic, jejichž aktivací se spouští ostření či snímání, nicméně naše verze má jednoduché tlačítko, které slouží pouze pro snímání. Správné kontakty můžete identifikovat prozkoumáním tištěného spoje, nebo prostudováním datasheetu.

Pro propojení bezdrátové dálkové spouště a GPIO Hackerboardu opět využijeme kabel se 4-pólovým konektorem jack 2,5 mm, ale tentokrát v trochu odlišném provedení. Namísto konektorů na obou stranách budeme potřebovat, aby na jedné straně byly odhalené vodiče, které následně připájíme na tištěný spoj dálkové spouště. Tento kabel můžete získat dvěma způsoby: buď si koupíte připravený kabel, nebo si jej vyrobíte odstřižením konektoru standardního jack-na-jack kabelu, a následně z něj zde opatrně oholíte izolaci, abyste se dostali k samotným vodičům. Pomocí multimetru můžete zjistit, které ze čtyř vodičů odpovídají kterým segmentům na konektoru jack. K propojení využijeme stejné dva kontakty, které jsme použili v předchozím příkladu, tedy první (0) a poslední (GND / Zem) segment konektoru jack. Jakmile správně identifikujete oba vodiče, připájejte je ke kontaktům tlačítka na tištěném spoji dálkové spouště. Zbývající vodiče odstřihněte a tělo dálkové spouště opětovně sestavte.

Připojte GPIO Hackerboard k tiskárně a zapněte ji. Poté zapojte 2,5 mm jack do zdířky na GPIO Hackerboardu, namiřte bezdrátovou dálkovou spoušť na připravený fotoaparát, a spusťte tisk s připravenou G-code sekvencí. Stejně jako tomu bylo v předchozím příkladu, i zde by nyní tiskárna měla při každém dokončení tiskové vrstvy odjet tiskovou hlavou do strany a následně vyslat (bezdrátový) signál do fotoaparátu, aby pořídil snímek.

Chcete vidět detailnější vizuální návod na úpravu a použití bezdrátové dálkové spouště s GPIO Hackerboardem? Člen 3D tiskové komunity Martin Zeman vytvořil skvělé video, které vás provede celým procesem:“

Vytváření fotografií pomocí chytrého telefonu a ESP32 s Bluetooth

Co takhle posunout tento projekt na trošku vyšší úroveň? Namísto digitálního fotoaparátu můžete využít svůj chytrý telefon. Kvalita fotografií je u většiny moderních telefonů pro vytváření dobře vypadajících časosběrných videí více než dostačující. Stačí vám GPIO Hackerboard a malá deska ESP32 se zabudovaným Bluetooth, a můžete si postavit vlastní bezdrátovou spoušť pro váš telefon.

Abyste tento projekt dali dohromady, budete kromě pájení potřebovat i trochu programování. Celá příprava je tak maličko složitější, jelikož vyžaduje vytvoření a nahrání zdrojového kódu do desky ESP32. Deska následně zpracovává stejný signál z GPIO Hackerboardu, jako v předchozím příkladu. Namísto přímého ovládání kontaktů v digitálním fotoaparátu zde však pošle příkaz do vašeho telefonu přes Bluetooth, kterým bude simulovat stisk tlačítka pro zvýšení hlasitosti. To totiž většinou funguje také jako spoušť v aplikaci pro focení.

Na GPIO Hackerboardu si nejprve propájejte kontakty JP7, abyste aktivovali integrovaný pull-up rezistor. Následně pájením propojte kontakt GND na Hackerboardu s GND na ESP32 a kontakt OUT7 s D3 (GPIO5) na ESP32.

Pojďme přejít k softwarové části. Níže naleznete kód, který jsme použili pro naši verzi desky ESP32. Berte ho jako inspiraci pro váš vlastní projekt.

Poznámka: tento kód zde poskytujeme tak, jak je, bez jakékoli záruky na funkčnost. S největší pravděpodobností jej budete muset upravit pro váš vlastní hardware.

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLEAdvertising.h>
#include <BLEHIDDevice.h>
#include <BLESecurity.h>
// Include necessary ESP-IDF headers
#include "esp_gatt_defs.h"
#include "esp_bt_defs.h"
#include "esp_bt_main.h"

// --- Constants ---
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 Configuration ---
const int TRIGGER_PIN = 5; // Use GPIO5 (Pin D5 on XIAO ESP32-C3)
int lastPinState = HIGH; // Assume pin starts HIGH due to INPUT_PULLUP
int currentPinState = HIGH;
unsigned long lastDebounceTime = 0; // Timer for debouncing
const unsigned long debounceDelay = 50; // Debounce time in milliseconds

// Cooldown variables (restored)
unsigned long lastTriggerTime = 0;
const unsigned long triggerCooldown = 500; // Minimum ms between triggers


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

// --- HID Report Map ---
// (Same as before)
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 ---
// (Remains the same)
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 ---
// (Remains the same - simplified 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 Function ---
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("Starting Single Pin Trigger Test (D5)...");

// *** Configure ONLY the trigger GPIO pin (D5/GPIO5) ***
pinMode(TRIGGER_PIN, INPUT_PULLUP);
lastPinState = digitalRead(TRIGGER_PIN); // Read initial state
currentPinState = lastPinState; // Assume initial state is stable
Serial.print("Monitoring Trigger Pin D");
Serial.print(TRIGGER_PIN); // Prints 5 now
Serial.print("(GPIO");
Serial.print(TRIGGER_PIN);
Serial.println(") configured as INPUT_PULLUP.");

// --- Restore Full BLE Setup ---
BLEDevice::init(DEVICE_NAME);
BLEDevice::setSecurityCallbacks(new MySecurityCallbacks());
Serial.println("BLE Initialized & Security Callbacks Set");
BLEServer *pServer = BLEDevice::createServer();
pServer->setCallbacks(new MyServerCallbacks());
Serial.println("BLE Server Created with Connection Callbacks");
pHid = new BLEHIDDevice(pServer);
Serial.println("BLE HID Device Created");
pInputConsumer = pHid->inputReport(1);
if (pInputConsumer == nullptr) { Serial.println("ERROR: Failed to create InputConsumer characteristic!"); while(1) delay(1000); }
Serial.println("Consumer Control Input Characteristic Ready");
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 Configured for Bonding");
pHid->startServices();
Serial.println("HID Services Started");
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 Started - Ready for GPIO trigger on D5");
Serial.println("------------------------------------");
}

// --- Send Consumer Control Report ---
// (Function remains the same)
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 Function (Single Pin Check) ---
void loop() {
// *** Read ONLY the defined trigger pin state (D5/GPIO5) ***
int reading = digitalRead(TRIGGER_PIN);

// Check if the pin state has changed
if (reading != lastPinState) {
lastDebounceTime = millis(); // Reset the debounce timer
}

// Check if debounce delay has passed
if ((millis() - lastDebounceTime) > debounceDelay) {
// If the pin state is stable and different from the last confirmed state
if (reading != currentPinState) {
currentPinState = reading; // Update the current confirmed state

// We trigger specifically when the pin goes LOW
if (currentPinState == LOW) {
// Check trigger cooldown
if (millis() - lastTriggerTime > triggerCooldown) {
Serial.print(">>> Triggering Action for Pin D");
Serial.print(TRIGGER_PIN); // Should print 5
Serial.println(" (LOW state confirmed)");
send_consumer_report(VOLUME_UP_BIT); // Send Volume Up command
lastTriggerTime = millis(); // Reset cooldown timer
} else {
Serial.print("Trigger Pin D"); Serial.print(TRIGGER_PIN); Serial.println(" went LOW, but in cooldown.");
}
} else {
// Optional: Log when pin goes back HIGH
Serial.print("Trigger Pin D"); Serial.print(TRIGGER_PIN); Serial.println(" went HIGH (Idle)");
}
}
}
// Update lastPinState for the next loop iteration
lastPinState = reading;

delay(5); // Small delay
}

Tento kód nyní musíme nahrát do desky ESP32, k čemuž využijeme software Arduino IDE. Struktura menu a názvy položek se mohou lišit v závislosti na verzi aplikace nebo platformě, kterou používáte.

Nejprve si desku připojíme k počítači přes USB, spustíme Arduino IDE a nainstalujeme si balíček s ovladači desky. Otevřeme si nabídku File -> Preferences a do pole „Additional Boards Manager URLs“ vložíme tuto URL: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json. Poté přejdeme do Tools -> Board -> Boards Manager, vyhledáme „ESP32“, vybereme nejnovější verzi balíčku ESP32 a nainstalujeme jej. Nyní vybereme model naší desky v Tools -> Board -> ESP32. A konečně, otevřeme si Tools -> Port a vybereme správný sériový port, ke kterému je naše deska připojená.

Nyní si můžeme nahrát připravený kód do ESP32. Smažte předgenerovaný kód v Arduino IDE a vložte do něj ten, který jsme si ukázali výše. Stiskněte tlačítko Upload (malá šipka), a počkejte, až Arduino IDE dokončí kompilaci a nahraje kód do desky.

Pokud se vám celý proces podařilo úspěšně dokončit, můžete nyní zkusit pomocí svého telefonu vyhledat Bluetooth zařízení s názvem „Prusa-Timelapse-Trigger“ (případně s jiným názvem, pokud jste jej v kódu změnili) a připojit se k němu. Můžete si také zobrazit stavové zprávy sériové komunikace pomocí Tools -> Serial Monitor.

Nyní si funkčnost celého řešení vyzkoušíme tak, že si nasimulujeme výstup z Hackerboardu. Stačí propojit kontakty na ESP32, se kterými jsme pracovali, tedy D3/GPIO5 a GND. Po jejich propojení byste na svém telefonu měli vidět, jak se zvyšuje úroveň hlasitosti (případně udělá snímek, pokud máte otevřenou aplikaci fotoaparátu). Pokud vše funguje, máte vyhráno. Odpojte ESP32 z počítače a připojte jej ke standardnímu napájecímu adaptéru s USB-C. GPIO Hackerboard nyní můžete připojit k tiskárně (opět, nezapomeňte ji nejprve vypnout).

Před spuštěním tisku budeme muset ještě lehce upravit G-code v PrusaSliceru, aby namísto výstupu OUT0 spínal výstup OUT7. To provedeme jednoduše tak, že v sekcích Začátek G-code a G-code po změně vrstvy přepíšeme všude P0 na P7.

Jakmile nyní spustíme tisk, pokaždé, když dojde ke změně vrstvy, GPIO Hackerboard vyšle signál do ESP32. To jej zpracuje a vyšle vlastní signál do chytrého telefonu, aby zvýšil hlasitost. Pokud je na telefonu otevřená aplikace fotoaparátu, tento signál donutí telefon udělat snímek.

A to je vše, přátelé! Tento příklad je samozřejmě jen jedním z mnoha způsobů, jakým můžete GPIO Hackerboard využít. Neváhejte naše řešení dále vylepšit, nebo přizpůsobit k obrazu svému. Těšíme se na vaše nápady, jak tento malý a chytrý modul využijete vy. Detailnější instrukce k GPIO Hackerboardu pak můžete nalézt na našem helpu.

Tisku zdar!