Nasze drukarki zawsze były otwarte na różne modyfikacje, a dzięki naszej płytce GPIO Hackerboard, możliwości są jeszcze większe. Ten opcjonalny dodatek już wzbudził duże zainteresowanie użytkowników, którzy lubią eksperymentować i odkrywać nowe sposoby ulepszania swoich drukarek Original Prusa MK4/S i Prusa CORE One. Dla tych, którzy jeszcze nie odkryli potencjału płytki Prusa GPIO Hackerboard, przygotowaliśmy projekt, który wykorzystuje ją do tworzenia timelapse’ów (filmów poklatkowych) z wydruków 3D. Ten przykład pokazuje, jakie są możliwości i mamy nadzieję, że zainspiruje Cię do własnych modyfikacji.

Krótka uwaga: ten projekt został stworzony do współpracy z wysokiej klasy aparatami cyfrowymi, aby zapewnić najlepszą możliwą jakość zdjęć do timelapse’ów. Jednak dla tych, którzy szukają prostszego, bardziej zintegrowanego rozwiązania, niedawno wydaliśmy aktualizację firmware dla naszych kamer Buddy3D, która dodaje możliwość robienia zdjęć w trybie timelapse bezpośrednio z tej kamery, co może sprawdzić się idealnie w wielu projektach. Zapoznaj się z naszym artykułem na temat tej dużej aktualizacji tutaj.

UWAGA: Wszystkie modyfikacje i podłączenia wykonujesz na własną odpowiedzialność. Nie ponosimy żadnej odpowiedzialności za uszkodzenia urządzeń, które mogą wystąpić na przykład w wyniku nieprawidłowego podłączenia, niewłaściwej obsługi lub nieprzestrzegania instrukcji.

Timelapse z wydruku wykonany aparatem cyfrowym

W jednym z poprzednich artykułów opisaliśmy szczegółowo tworzenie pięknych filmów poklatkowych przy użyciu aparatu cyfrowego i specjalnie wykonanego przewodu podłączonego bezpośrednio do płyty głównej drukarek MK3/S i MK2.5/S. Oryginalny artykuł znajdziesz tutaj.

W tym rozwiązaniu piny na płycie głównej były sterowane instrukcjami G-code, które wzbudzały napięcie na nich. Sygnał aktywował następnie obwód w przewodzie i wyzwalał migawkę aparatu. Metoda ta działała, jednak była dość skomplikowana, ponieważ wymagała podłączenia przewodów DuPont bezpośrednio do pinów płyty głównej drukarki, co stwarzało ryzyko pomyłki. Płytka GPIO Hackerboard zapewnia podobne, ale bardziej estetyczne rozwiązanie. Jest podłączana do płyty głównej drukarki MK4/S lub CORE One za pomocą prostego złącza I2C, a instrukcje G-code aktywują jeden z ośmiu pinów wejścia/wyjścia płytki, umożliwiając łatwe sterowanie urządzeniami zewnętrznymi.

Aby tworzyć filmy poklatkowe z wydruków 3D, możesz użyć zarówno przewodowych, jak i bezprzewodowych zdalnych wyzwalaczy migawki, w zależności od tego, co obsługuje aparat. Preferowanym rozwiązaniem jest jednak użycie wyzwalacza bezprzewodowego, ponieważ jest on całkowicie odizolowany od elektroniki i zasilania drukarki, zapewniając bezpieczeństwo aparatu przez cały czas. Pokażemy Ci oba rozwiązania, dzięki czemu możesz wybrać to, które najlepiej odpowiada Twoim potrzebom.

Pamiętaj: zanim podłączysz lub odłączysz płytkę GPIO Hackerboard, zawsze najpierw wyłącz drukarkę, aby uniknąć potencjalnego uszkodzenia płytki GPIO lub samej drukarki!

Przewodowy pilot zdalnego wyzwalania migawki

Najpierw przyjrzyjmy się podłączeniu aparatu do płytki GPIO Hackerboard z użyciem przewodu. Należy pamiętać, że różne aparaty wymagają różnych metod podłączenia i wyzwalania migawki. Na przykład niektóre mogą wymagać obwodu elektrycznego z określonymi rezystorami (takiego jak ten, który zbudowaliśmy dla naszego aparatu Panasonic Lumix DC-GH5 w tym artykule) lub użycia specyficznych złączy. Inne natomiast wymagają jedynie zmostkowania styków na standardowym przewodzie jack 2,5 mm.

W tym przewodniku skupimy się na tym prostym rozwiązaniu wykorzystującym przewód z czteropolowym wtykiem jack 2,5 mm na obu końcach. Takie podejście eliminuje konieczność lutowania, upraszczając cały proces i umożliwiając łatwe podłączanie i odłączanie w razie potrzeby.

Najpierw podłącz płytkę GPIO Hackerboard do drukarki (nie zapomnij jej wcześniej wyłączyć). Następnie podłącz jeden koniec przewodu jack do płytki Hackerboard, a drugi koniec do aparatu. Teraz możesz ponownie włączyć drukarkę.

Następnie sprawdźmy, które segmenty złącza jack 2,5 mm musimy połączyć, aby aparat wykonał zdjęcie. Poniżej znajduje się schemat ilustrujący połączenia, które uruchamiają autofokus, a które wyzwalają migawkę (jest to specyficzne dla naszego modelu aparatu). W tym przypadku, aby wyzwolić migawkę, połączymy pierwszy (0) i ostatni (GND) segment złącza jack 2,5 mm. Będzie to kontrolowane przez kilka prostych instrukcji G-code wprowadzonych do PrusaSlicera.

Zanim przejdziemy do PrusaSlicera, szybko ustawmy aparat, aby uzyskać dobry widok stołu drukarki i upewnić się, że ustawienia, w tym ostrość, są prawidłowe. Po ustawieniu aparatu przełącz go w tryb manualnej ostrości.

Otwórz PrusaSlicera, wybierz drukarkę i zaimportuj model, który chcesz wydrukować. Następnie przejdź do zakładki Drukarki w górnym menu i wybierz opcję Własny G-code z menu po lewej stronie. Jeśli nie widzisz tej opcji, przełącz PrusaSlicer do trybu ekspertaw menu rozwijanym w prawym górnym rogu ekranu, obok ikony użytkownika.

Tutaj znajdziesz polecenia G-code, które są wykonywane podczas wydruku, niezależnie od drukowanego modelu, ustawień itp. Obejmują one instrukcje wykonywane przed rozpoczęciem wydruku, po jego zakończeniu lub przed/po każdej zmianie warstwy itp. Skupimy się na polach G-code startowy oraz G-code po zmianie warstwy. W polu G-code startowy ustawimy Pin 0 jako wyjście, wstawiając tam odpowiednie instrukcje na samym końcu tej sekcji (tekst po średniku jest komentarzem i nie stanowi wykonywanego kodu):

; Set Pin 0 as output

M262 P0 B0

Następnie, w polu G-code po zmianie warstwy uruchomimy właściwą sekwencję wyzwalania migawki. Oznacza to, że po zakończeniu drukowania każdej warstwy głowica drukująca zostanie odsunięta, aby zapewnić wyraźny obraz, a następnie aparat wykona zdjęcie. Głowica zaczeka chwilę, a następnie wróci do pierwotnej pozycji. Drukowanie będzie kontynuowane aż do zmiany kolejnej warstwy. Umieśćmy te instrukcje na końcu sekcji:

G1 X160 Y160 F{travel_speed*60} ;Move away from the print

G4 S0 ;Wait for move to finish

G4 P150 ;Wait for 150ms to give the bed time to stop properly

M265 P0 ;Flip the pin status to 1 to trigger the shutter

M265 P0 ;Flip the pin status back to 0

G4 P250 ;Wait for 250ms to give the camera time to finish the capture

Konfigurację możesz zapisać używając ikony zapisu w górnym menu, dzięki czemu możesz łatwo przełączać się między profilami wydruku normalnego i poklatkowego.

Teraz możesz wrócić do zakładki Zawartość stołu, nacisnąć przycisk Cięcie i wysłać gotowy G-code do drukarki. Po rozpoczęciu drukowania aparat będzie wyzwalany po zakończeniu każdej warstwy, zapewniając wyraźne, stabilne ujęcie wydruku w trakcie realizacji. Wystarczy kilka linii G-code, aby uchwycić piękne sekwencje zdjęć, warstwa po warstwie!

Jeśli wszystko poszło zgodnie z planem, otrzymasz wiele udanych zdjęć z trwającego wydruku. Teraz musimy przekształcić je w film poklatkowy. W tym celu użyjemy świetnego programu do edycji wideo, DaVinci Resolve, który możesz pobrać bezpłatnie tutaj.

Tworzenie timelapse’u w DaVinci Resolve

Najpierw zainstaluj i otwórz DaVinci Resolve, a następnie utwórz nowy projekt. Zanim zaczniesz, przejdź do zakładki Media, czyli pierwszej na dolnym pasku menu. W górnym menu kliknij przycisk z trzema kropkami i upewnij się, że opcja Frame Display Mode jest przełączona na Sequence. To ustawienie powoduje, że Resolve łączy wszystkie zaimportowane zdjęcia w jeden klip wideo, zamiast setek (lub nawet tysięcy, w przypadku dłuższych filmów) pojedynczych obrazów.

Teraz przejdź do strony Edit. Aby zaimportować zdjęcia, znajdź je w folderze na komputerze i zaznacz wszystkie. Po zaznaczeniu wszystkich plików przeciągnij je i upuść do obszaru Master po lewej stronie ekranu. Spowoduje to automatyczne utworzenie jednego lub kilku klipów sekwencyjnych ze wszystkich obrazów. Teraz przeciągnij i upuść klipy na oś czasu. Możesz wyświetlić podgląd wygenerowanego timelapse’u, naciskając przycisk odtwarzania lub przeciągając czerwoną linię po osi czasu. Możesz również zmienić liczbę klatek na sekundę i zastosować różne efekty, takie jak korekcja kolorów, stabilizacja obrazu i wiele innych.

Wynik może wyglądać tak:

W instrukcjach G-code możesz dostosować wartości, takie jak pozycja głowicy drukującej lub czasy parkowania przy tworzeniu ujęcia. Pamiętaj jednak jednak, że dłuższy czas przemieszczania zwiększa ryzyko wyciekania filamentu z nagrzanej dyszy. Może to potencjalnie spowodować powstawanie artefaktów lub nitek. Aby zminimalizować ten problem, zawsze używaj dobrze wysuszonego filamentu i unikaj ustawiania zbyt długich odległości przemieszczania głowicy.

Teraz, gdy już wiesz, jak stworzyć timelapse z aparatu podłączonego przewodowo, przyjrzyjmy się kilku innym opcjom. Zaczniemy od bezprzewodowego zdalnego wyzwalacza migawki do aparatu cyfrowego, a następnie przejdziemy do nieco bardziej zaawansowanej metody wykorzystującej smartfon.

Bezprzewodowy pilot do wyzwalania migawki

Rozwiązanie bezprzewodowe wymaga nieco lutowania, ale mimo to jest bardzo proste, a konfiguracja G-code jest identyczna jak w poprzednim przykładzie.

Używamy aparatów Sony Alpha, więc kupiliśmy niedrogi bezprzewodowy pilot zdalnego wyzwalania migawki od Sony. Pilot dla konkretnego modelu aparatu lub uniwersalny możesz zamówić online za kilkanaście-kilkadziesiąt złotych.

Rozmontuj go, aby uzyskać dostęp do wewnętrznej płytki drukowanej i zidentyfikować parę styków, które są mostkowane po naciśnięciu przycisku spustu. Chociaż niektóre przyciski mają wiele pozycji do ustawiania ostrości i wyzwalania, ten konkretny pilot wyzwala tylko migawkę. Okablowanie możesz rozpoznać, przyglądając się płytce drukowanej lub znaleźć je na jej schemacie.

Do połączenia pilota migawki z płytką GPIO Hackerboard ponownie użyjemy przewodu z 4-polowym wtykiem jack 2,5 mm, ale w innej konfiguracji. Zamiast wtyku na obu końcach potrzebujemy odsłoniętych przewodów z jednej strony, które przylutujemy do płytki drukowanej pilota. Przewód ten możesz otrzymać na dwa sposoby: kupić gotowy lub wykonać samodzielnie, przecinając standardowy przewód jack-jack i ostrożnie zdejmując izolację z jednego końca, aby odsłonić wewnętrzne przewody. Za pomocą multimetru ustal, które z czterech przewodów odpowiadają odpowiednim segmentom wtyku. Użyjemy tych samych dwóch styków, co na ilustracji w poprzedniej sekcji – pierwszego (0) i ostatniego (GND). Po zidentyfikowaniu dwóch właściwych przewodów przylutuj je do styków przycisku na płytce drukowanej pilota. Odetnij pozostałe dwa przewody i złóż obudowę pilota.

Teraz podłącz płytkę GPIO Hackerboard do drukarki i włącz ją. Następnie podłącz wtyk 2,5 mm do gniazda na płytce GPIO Hackerboard, ustaw pilota w stronę aparatu i rozpocznij drukowanie przy użyciu przygotowanej sekwencji G-code dla timelapse’u. Podobnie jak w poprzednim przykładzie, drukarka powinna zatrzymać się przy każdej zmianie warstwy i wysłać (bezprzewodowy) sygnał do aparatu, aby zrobił zdjęcie.

Jeśli potrzebujesz wizualnego przewodnika na temat lutowania i korzystania z bezprzewodowego zdalnego wyzwalacza migawki we współpracy z GPIO Hackerboard, Martin Zeman, członek społeczności druku 3D, przygotował świetny film pokazujący cały proces:

Robienie zdjęć smartfonem przez Bluetooth i ESP32

Chcesz pójść o krok dalej? Zamiast aparatu cyfrowego możesz użyć smartfona. Jakość zdjęć jest więcej niż wystarczająca do świetnie wyglądającego filmu poklatkowego. Dzięki płytce GPIO Hackerboard i małej płytce ESP32 z łącznością Bluetooth możesz zbudować własny bezprzewodowy zdalny pilot do wyzwalania migawki swojego smartfona.

Aby go zbudować, oprócz lutowania, konieczne będzie również trochę programowania. Konfiguracja jest bardziej złożona, ponieważ wymaga utworzenia i przesłania określonego kodu do płytki ESP32. Płytka obsługuje ten sam sygnał z płytki GPIO Hackerboard, co w poprzednim przykładzie, jednak zamiast wyzwalać styki aparatu cyfrowego, wysyła polecenie do telefonu przez Bluetooth, symulując naciśnięcie przycisku głośności, który zwykle służy jako przycisk migawki.

Najpierw na płytce GPIO Hackerboard połącz styki JP7, lutując je, aby włączyć zintegrowany rezystor podciągający. Następnie zlutuj połączenia między płytkami: podłącz styk GND płytki Hackerboard do styku GND na płytce ESP32, a styk OUT7 do styku D3 (GPIO5) na płytce ESP32.

Przejdźmy do strony programowej. Poniżej zamieściliśmy przykładowy kod, którego użyliśmy do uruchomienia naszej konkretnej płytki ESP32. Możesz potraktować go jako inspirację do rozpoczęcia własnego projektu.

Uwaga: ten kod jest dostarczany w stanie, w jakim jest, bez żadnej gwarancji działania. Prawdopodobnie konieczne będzie dostosowanie go do pracy z Twoim konkretnym sprzętem.

#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
}

Musimy wgrać ten kod do płytki ESP32 korzystając z oprogramowania Arduino IDE. Struktura menu i nazwy elementów mogą się różnić w zależności od wersji aplikacji lub używanej platformy.

Najpierw podłącz płytkę ESP32 do komputera przez USB, uruchom Arduino IDE i zainstaluj ESP32 board package, przechodząc do menu File -> Preferences i wklejając poniższy URL w pole Additional Boards Manager URLs: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json. Następnie otwórz menu Tools -> Board -> Boards Manager, wyszukaj “ESP32”, wybierz najnowszą wersję ESP32 i zainstaluj ją. Teraz wybierz swoją płytkę w menu Tools -> Board -> ESP32. Na koniec, w menu Tools -> Port wybierz odpowiedni port szeregowy oraz nazwę podłączonej płytki.

Teraz możesz przesłać kod do ESP32. Usuń wygenerowany kod w Arduino IDE i wklej kod zamieszczony powyżej. Naciśnij przycisk Upload (strzałka) i poczekaj, aż Arduino IDE skompiluje, a potem prześle kod do płytki. 

Jeśli wszystko zostało wykonane poprawnie, w smartfonie spróbuj wyszukać urządzenie Bluetooth o nazwie „Prusa-Timelapse-Trigger” (lub innej, jeśli została zmieniona w kodzie) i połącz się z nim. Aby sprawdzić komunikaty o stanie w komunikacji szeregowej, przejdź do Tools -> Serial Monitor.

Teraz możesz przetestować wyzwalacz, symulując sygnał z Hackerboard. Użyj pęsety lub cienkiego przewodu, aby na chwilę podłączyć pin wejściowy ESP32 (D3/GPIO5) do pinu GND. Powinien pojawić się suwak/menu zmiany poziomu głośności w telefonie. Jeśli tak się stanie, wszystko jest gotowe. Odłącz ESP32 od komputera i podłącz go do standardowego zasilacza USB-C. Teraz możesz podłączyć płytkę GPIO Hackerboard do drukarki. Nie zapomnij wyłączyć drukarki przed podłączeniem płytki Hackerboard!

Musimy nieco zmodyfikować G-code w PrusaSlicerze, aby uruchamiał wyjście OUT7 zamiast OUT0. Zrobimy to, zmieniając po prostu P0 na P7 w sekcjach G-code startowy i G-code po zmiane warstwy. Teraz, po rozpoczęciu wydruku, za każdym razem, gdy nastąpi zmiana warstwy, płytka GPIO Hackerboard wyśle sygnał do ESP32, który następnie wyśle polecenie zmiany głośności w telefonie. Jeśli aplikacja aparatu jest włączona, spowoduje to uruchomienie migawki i zrobienie zdjęcia.

I to wszystko! To tylko jedno z wielu możliwych zastosowań płytki GPIO Hackerboard. Zachęcamy do modyfikowania i ulepszania tych rozwiązań. Czekamy na Twoje pomysły na wykorzystanie tego małego i sprytnego modułu. Szczegółowe instrukcje dotyczące płytki GPIO znajdziesz tutaj.

Udanego drukowania!