Le nostre stampanti sono sempre state pronte per essere modificate in vari modi dagli utenti e, con la nostra GPIO Hackerboard, estendiamo ancora di più queste possibilità. Questo accessorio opzionale ha già attirato l’attenzione di chi ama sperimentare e scoprire nuovi modi per migliorare le proprie configurazioni Original Prusa MK4/S e Prusa CORE One. Per chi non ha ancora esplorato il potenziale della scheda Prusa GPIO Hackerboard, abbiamo preparato un progetto che la utilizza per creare un video time-lapse della tua stampa 3D. Questo esempio mette in risalto le possibilità offerte e speriamo che possa ispirare idee per le vostre modifiche personali.

Una piccola nota a margine, Questo progetto è stato ideato per consentire l’utilizzo di fotocamere digitali di fascia alta, ottenendo la migliore qualità possibile delle immagini per i vostri timelapse. Tuttavia, per chi è alla ricerca di una soluzione più semplice e integrata, abbiamo recentemente rilasciato un aggiornamento del firmware per le nostre fotocamere Buddy3D. Questo aggiornamento aggiunge la possibilità di scattare foto per un timelapse direttamente con la fotocamera Buddy3D stessa, che può essere una soluzione perfetta per molti progetti. Date un’occhiata al nostro articolo su questo importante aggiornamento qui.

AVVERTENZA: Tutte le modifiche e i collegamenti sono eseguiti a proprio rischio e pericolo. Non ci assumiamo alcuna responsabilità per i danni al dispositivo che possono verificarsi, ad esempio, a causa di un cablaggio errato, di un uso improprio o della mancata osservanza delle istruzioni.

Timelapse di Stampa con una fotocamera digitale

In uno dei nostri articoli precedenti, abbiamo pubblicato una guida dettagliata su come realizziamo i nostri splendidi video timelapse utilizzando una fotocamera digitale e un cavo personalizzato collegato direttamente alla scheda madre Einsy RAMBo nelle stampanti MK3/S e M2.5/S. Potete trovare l’articolo originale qui.

In questa soluzione, i pin dell’Einsy RAMBo erano controllati da istruzioni G-code che attivavano una tensione di output. Il segnale di tensione attivava quindi un circuito all’interno del cavo e faceva scattare l’otturatore della fotocamera. Questo metodo funzionava, ma era piuttosto complesso, poiché richiedeva il collegamento dei cavi DuPont direttamente ai pin della scheda madre della stampante, con il rischio di un cablaggio errato. La scheda GPIO Hackerboard offre una soluzione simile, ma più elegante. È collegata alla scheda madre di una stampante MK4/S o CORE One tramite un semplice connettore I2C e le istruzioni G-code attivano uno degli otto pin I/O della scheda Hackerboard, consentendo di controllare facilmente i dispositivi esterni.

Per creare timelapse di stampe 3D, è possibile utilizzare otturatori remoti sia cablati che wireless, a seconda del supporto della fotocamera. La soluzione preferibile, tuttavia, è quella di utilizzare un otturatore wireless, in quanto è completamente isolato dall’elettronica e dall’alimentazione della stampante, mantenendo la fotocamera sempre al sicuro. Vi mostriamo entrambe le soluzioni, in modo che possiate scegliere quella più adatta alle vostre esigenze.

Attenzione: Spegnere sempre la stampante prima di collegare la GPIO Hackerboard, per evitare potenziali danni alla GPIO Hackerboard o alla stampante!

Otturatore remoto cablato

Per prima cosa, vediamo come collegare una fotocamera alla GPIO Hackerboard con un cavo. È importante sapere che le diverse fotocamere richiedono metodi diversi per il collegamento e l’attivazione di un otturatore remoto. Ad esempio, alcune possono richiedere un circuito elettrico con determinate resistenze (come quello che abbiamo costruito per la nostra Panasonic Lumix DC-GH5 in un precedente articolo), o utilizzare connettori specifici. Altri, invece, richiedono semplicemente contatti a ponte su un cavo jack standard da 2,5 mm per attivare uno scatto.

In questa guida ci concentreremo su questa semplice soluzione, utilizzando un cavo con un jack a 4 poli da 2,5 mm su entrambe le estremità. Questo approccio elimina la necessità di saldare, semplificando l’intero processo e consentendo di collegare e scollegare facilmente il circuito secondo le necessità.

Per prima cosa, collegare la Hackerboard GPIO alla stampante (senza dimenticare di spegnerla prima). Quindi, collegare un’estremità del cavo jack alla Hackerboard e l’altra alla fotocamera. A questo punto è possibile riaccendere la stampante.

Controlliamo quindi quali segmenti del connettore jack da 2,5 mm dobbiamo collegare per far scattare una foto alla fotocamera. Di seguito è riportato un diagramma che illustra quali collegamenti attivano l’autofocus e quali l’istantanea (questo è specifico per il nostro modello di fotocamera). In questo caso, per attivare l’istantanea, collegheremo il primo (0) e l’ultimo (GND) segmento del connettore jack da 2,5 mm. Questo sarà controllato da alcune semplici istruzioni G-code inserite in PrusaSlicer.

Prima di procedere con PrusaSlicer, impostiamo rapidamente la fotocamera per avere una buona visione del piano di stampa e per garantire le impostazioni corrette della fotocamera, compresa la messa a fuoco. Dopo aver completato le impostazioni, passare la fotocamera alla modalità di messa a fuoco manuale.

Aprire PrusaSlicer, selezionare la stampante e importare il modello da stampare. Quindi, passare alla scheda Stampanti nel menu superiore e selezionare la voce “G-code personalizzato” dal menu a sinistra. Se non vedete questa opzione, passate PrusaSlicer alla Modalità Esperto (Rosso) utilizzando il menu a tendina situato nell’angolo in alto a destra dello schermo, accanto all’icona dell’utente.

Qui si trovano i comandi G-code che vengono eseguiti durante ogni stampa, indipendentemente dal modello stampato, dalle impostazioni, ecc. Si tratta di istruzioni che vengono eseguite prima dell’inizio della stampa, al termine della stessa, prima/dopo ogni cambio di layer e così via. Ci concentreremo sulle sezioni G-code iniziale e G-code dopo il cambio layer. Nella sezione G-code iniziale, impostiamo il pin 0 come uscita posizionando questa istruzione alla fine della sezione (il testo dopo il punto e virgola è un commento e non influenza il codice):

M262 P0 B0; Imposta il pin 0 come output 

Successivamente, nella sezione G-code dopo il cambio layer, attiveremo la sequenza di istantanee vera e propria. Ciò significa che ogni volta che uno strato stampato viene terminato, la testina di stampa viene spostata per garantire un’inquadratura chiara e viene scattata una foto. La testina di stampa attende per un momento e poi ritorna alla posizione originale. La stampa continuerà fino al successivo cambio di layer. Anche in questo caso, queste istruzioni saranno inserite alla fine della sezione:

G1 X160 Y160 F{travel_speed*60} ;Allontanarsi dalla stampa
G4 S0 ;Attendere il completamento del movimento
G4 P150 ;Attendere 150 ms per dare al piano il tempo di fermarsi correttamente
M265 P0 ;Portare lo stato del pin su 1 per attivare l'otturatore
M265 P0 ;Riporta a 0 lo stato del pin
G4 P250 ;Attendere 250 ms per dare alla fotocamera il tempo di terminare la cattura

È possibile salvare questa configurazione utilizzando l’icona di salvataggio nel menu superiore, in modo da poter passare facilmente dal profilo di stampa normale a quello timelapse.

Ora è possibile tornare alla scheda Piano, premere il pulsante Processa e inviare il G-code finale alla stampante. Dopo l’avvio del processo di stampa, la fotocamera scatterà costantemente al termine di ogni layer, fornendo una ripresa chiara e stabilizzata della stampa in corso. Con poche righe di G-code, siete pronti a catturare bellissimi timelapse layer-by-layer!

Se tutto ha funzionato correttamente, ora dovreste avere molte belle foto della stampa in corso. Ora dobbiamo trasformarle in un video in timelapse. A tale scopo, utilizzeremo l’eccellente software di editing video DaVinci Resolve, disponibile per il download gratuito qui.

Creazione di un video timelapse con DaVinci Resolve

Innanzitutto, installate e aprite DaVinci Resolve e create un nuovo progetto. Prima di fare qualsiasi altra cosa, passare alla scheda Media, che è la prima icona del menu in basso sullo schermo. A questo punto, nel menu superiore, fate clic sul pulsante con i tre puntini e assicuratevi che l’opzione ‘Modalità di visualizzazione fotogrammi’ sia impostata su ‘Sequenza’. Questa impostazione indica a Resolve di unire tutte le foto importate in un unico video clip, anziché in centinaia (o addirittura migliaia, per i timelapse più lunghi) di singole immagini.

A questo punto, passare alla pagina Modifica. Per importare le foto, individuarle nella loro cartella sul computer e selezionarle tutte. Una volta selezionati tutti i file, trascinarli e rilasciarli nell’area Master sul lato sinistro dello schermo. Questo creerà automaticamente una o più sequenze di clip da tutte le immagini. A questo punto, trascinare e rilasciare i clip nella cronologia. È possibile visualizzare l’anteprima della cronologia generata premendo il pulsante play o trascinando la linea rossa sulla timeline. È anche possibile modificare il framerate e applicare vari effetti di post-processing al video timelapse, come la gradazione del colore, la stabilizzazione dell’immagine e altro ancora.

Il risultato può essere simile a questo:

È possibile regolare i valori nelle istruzioni del G-code, quali la posizione della testina di stampa o i tempi di attesa in base alle proprie esigenze. Tuttavia, si tenga presente che un tempo di attesa più lungo aumenta il rischio di fuoriuscita del filamento dall’ugello caldo. Ciò può causare artefatti di stampa o stringing. Per ridurre al minimo questo problema, utilizzare filamenti ben essiccati ed evitare di impostare distanze di corsa troppo lunghe per la testina di stampa.

Ora che sapete come creare un video timelapse da una configurazione di fotocamera cablata, vediamo un paio di altre opzioni per catturare le foto. Inizieremo con un otturatore remoto wireless per la vostra fotocamera digitale e poi passeremo a un metodo leggermente più avanzato che utilizza il vostro smartphone.

Otturatore remoto senza fili

La soluzione wireless richiede un po’ di saldatura, ma è molto semplice e la configurazione del G-code è identica a quella dell’esempio precedente.

Utilizziamo le fotocamere Sony Alpha, quindi abbiamo acquistato un otturatore remoto IR wireless Sony a basso costo. In genere è possibile ordinare online versioni specifiche o universali di tali otturatori remoti, adatti a più marche, per pochi soldi.

Smontare l’otturatore per accedere al circuito stampato interno e identificare la coppia di contatti che vengono collegati quando si preme il pulsante di attivazione. Mentre alcuni pulsanti hanno posizioni multiple per la messa a fuoco e l’attivazione, questo particolare otturatore remoto attiva solo lo scatto. È possibile trovare il cablaggio corretto osservando la PCB o consultando la scheda tecnica.

Per il collegamento tra l’otturatore remoto wireless e la Hackerboard GPIO, utilizzeremo ancora una volta un cavo jack a 4 poli da 2,5 mm, ma con una configurazione diversa. Invece di avere un jack su entrambe le estremità, abbiamo bisogno di un’estremità con fili scoperti che saranno saldati alla scheda dell’otturatore remoto. Avete due modi per ottenere questo cavo: o acquistarne uno già pronto, o realizzarlo da soli tagliando un cavo jack-to-jack standard e spellando accuratamente un’estremità per esporre i fili interni.. Utilizzare un multimetro per identificare quali dei quattro fili corrispondono ai segmenti corretti del jack. Utilizzeremo gli stessi due contatti mostrati nello schema della sezione precedente: il primo (0) e l’ultimo (GND) segmento del connettore jack. Una volta identificati i due fili corretti, saldateli ai contatti del pulsante sulla scheda dell’otturatore remoto. Tagliate i due fili rimanenti e rimontate il corpo dell’otturatore remoto.

A questo punto, collegate la scheda GPIO Hackerboard alla stampante e accenderla. Quindi, inserite il cavo da 2,5 mm alla presa sulla Hackerboard GPIO, puntate il telecomando wireless verso la fotocamera e avviate la stampa con la sequenza G-code in timelapse preparata. Come nell’esempio precedente, la stampante deve fermarsi a ogni cambio di layer e inviare un segnale (wireless) alla fotocamera per scattare un’istantanea.

Per coloro che sono alla ricerca di una guida visiva sulla saldatura e sull’utilizzo dell’otturatore remoto wireless e della Hackerboard GPIO, Martin Zeman, un membro della community della stampa 3D, ha realizzato un ottimo video che illustra l’intero processo:

Scattare foto con uno smartphone tramite Bluetooth e ESP32

Volete fare un ulteriore passo avanti in questo progetto? Potete usare il vostro smartphone al posto di una fotocamera digitale. La qualità dell’immagine è più che sufficiente per creare un video timelapse di grande effetto. Con la Hackerboard GPIO e una piccola scheda ESP32 con connettività Bluetooth, potete costruire il vostro otturatore remoto senza fili per il vostro telefono.

Per costruirlo, oltre a saldare, è necessario fare un po’ di programmazione. La configurazione è più complessa, in quanto prevede la creazione e il caricamento di codice specifico sulla scheda ESP32. La scheda gestisce lo stesso segnale dalla Hackerboard GPIO, come nell’esempio precedente. Tuttavia, invece di attivare i contatti della fotocamera digitale, invia un comando al telefono tramite Bluetooth, simulando la pressione di un tasto del volume, che di solito funge da pulsante di scatto della fotocamera.

Per prima cosa, sulla Hackerboard GPIO, collegare i contatti JP7 saldandoli per abilitare la resistenza di pull-up integrata. Quindi saldare i collegamenti tra le schede: collegare il contatto GND della Hackerboard a un pin GND della scheda ESP32 e il contatto OUT 7 al pin D3 (GPIO5) dell’ESP32.

Passiamo al lato software. Di seguito, abbiamo incluso l’esempio di codice che abbiamo utilizzato per mettere in funzione la nostra scheda ESP32 specifica. Consideratelo un punto di partenza stimolante per il vostro progetto.

Nota bene: questo codice viene fornito così com’è e senza alcuna garanzia. È probabile che dobbiate adattarlo per farlo funzionare con il vostro hardware specifico.

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

Dobbiamo caricare questo codice sulla scheda ESP32 utilizzando il software Arduino IDE. La struttura del menu e i nomi delle voci possono variare a seconda della versione del programma o della piattaforma che stai usando.

Per prima cosa, collegate la scheda ESP32 al computer via USB, avviate l’IDE Arduino e installate il pacchetto della scheda ESP32 andando su File -> Preferenze e incollando il seguente URL nel campo “Additional Boards Manager URLs”: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json. Quindi andare su Strumenti -> Scheda -> Gestione schede, cercare “ESP32”, selezionare l’ultima versione di ESP32 e installarla. A questo punto, selezionare il modello di scheda in Strumenti -> Scheda -> ESP32. Infine, aprire Strumenti -> Porta e selezionare il nome corretto della porta seriale della scheda collegata.

Ora è possibile caricare il codice sull’ESP32. Cancella il codice che hai creato nell’IDE Arduino e incolla quello che trovi sopra.
Premete il pulsante Upload (freccia) e attendete che l’IDE Arduino compili e carichi il codice sulla scheda. 

Se tutto è stato eseguito correttamente, cercare il dispositivo Bluetooth denominato “Prusa-Timelapse-Trigger” (o un nome diverso, se è stato modificato nel codice) e collegarsi ad esso. Per verificare la presenza di messaggi di stato nella comunicazione seriale, andare su Strumenti -> Serial Monitor.

Ora è possibile testare l’innesco simulando il segnale dalla Hackerboard. Utilizzate una pinzetta o un piccolo filo per collegare brevemente il pin di ingresso dell’ESP32 (D3/GPIO5) a un pin GND. Il livello del volume del telefono dovrebbe cambiare. Se così fosse, il gioco è fatto. Scollegare l’ESP32 dal computer e alimentarlo con un adattatore di alimentazione USB-C standard. Ora è possibile collegare la scheda Hacker GPIO alla stampante. Non dimenticate di spegnere la stampante prima di collegare la Hackerboard!

Dobbiamo modificare leggermente il G-code in PrusaSlicer, in modo da attivare l’uscita OUT7 anziché OUT0. Per farlo, basta cambiare P0 in P7 nelle sezioni G-code Iniziale e G-code dopo cambio layer. Ora, quando si avvia la stampa, ogni volta che si verifica un cambio di layer, la Hackerboard GPIO invia un segnale all’ESP32, che a sua volta invia un comando per modificare il volume del telefono. Se l’app della fotocamera è attiva, l’otturatore si attiverà e scatterà una foto.

E questo è tutto! Questo è solo uno dei tanti possibili casi d’uso della Hackerboard GPIO. Sentitevi liberi di modificare e migliorare queste soluzioni. Non vediamo l’ora di vedere le vostre idee su come utilizzare questo piccolo e intelligente modulo. Le istruzioni dettagliate per la scheda GPIO sono disponibili nella nostra sezione aiuto.

Buona stampa!