Nuestras impresoras siempre han estado abiertas a diversas modificaciones de los usuarios, y con nuestra GPIO Hackerboard, ampliamos aún más estas posibilidades. Este complemento opcional ya ha recibido una gran atención por parte de los usuarios a los que les gusta experimentar y descubrir nuevas formas de mejorar sus configuraciones de las Original Prusa MK4/S y Prusa CORE One. Para aquellos que aún no han explorado el potencial de la Prusa GPIO Hackerboard, hemos preparado un proyecto que lo utiliza para crear un vídeo timelapse de tu impresión 3D. Este ejemplo destaca lo que es posible, y esperamos que te inspire ideas para tus propias modificaciones.

Como nota al margen, este proyecto está diseñado para que puedas utilizar cámaras digitales de gama alta, lo que te permitirá conseguir la mejor calidad de imagen posible para tus timelapses. Sin embargo, para aquellos que buscan una solución más sencilla e integrada, recientemente hemos lanzado una actualización de firmware para nuestras cámaras Buddy3D. Esta actualización añade la posibilidad de capturar fotos para un timelapse directamente con la propia cámara Buddy3D, lo que puede ser una solución perfecta para muchos proyectos. Consulta nuestro artículo sobre esta importante actualización aquí.

ADVERTENCIA: Todas las modificaciones y conexiones se realizan bajo tu propia responsabilidad. No asumimos ninguna responsabilidad por los daños que pueda sufrir cualquier dispositivo, por ejemplo, debido a un cableado incorrecto, una manipulación inadecuada o el incumplimiento de las instrucciones.

Timelapse de una Impresión con una Cámara Digital

En uno de nuestros artículos anteriores, hemos publicado una guía detallada sobre como crear hermosos timelapses usando una cámara digital conectada directamente a la placa de las impresoras MK3/S y M2.5/S. Puedes encontrar el artículo original aquí.

En esta solución, los pines de la placa base se controlaban mediante instrucciones de código G, que activaban una salida de tensión en ellos. La señal de tensión activaba entonces un circuito dentro del cable y accionaba el obturador de la cámara. Este método funcionaba, pero era bastante complejo, ya que requería conectar los cables DuPont directamente a los pines de la placa base de la impresora, con el consiguiente riesgo de cableado incorrecto. La GPIO Hackerboard ofrece una solución similar, pero más elegante. Se conecta a la placa base de una impresora MK4/S o CORE One a través de un sencillo conector I2C, y las instrucciones de código G activan uno de los ocho pines de E/S de la Hackerboard, lo que permite controlar fácilmente dispositivos externos.

Para crear timelapses de impresión 3D, puedes utilizar obturadores remotos tanto con cable como inalámbricos, dependiendo de lo que admita tu cámara. La solución preferida, sin embargo, es utilizar uno inalámbrico, ya que está completamente aislado de la electrónica y la alimentación de la impresora, manteniendo tu cámara a salvo en todo momento. Te mostramos ambas soluciones para que elijas la que mejor se adapte a tus necesidades.

Recuerda: Apaga siempre la impresora antes de conectar la GPIO Hackerboard, ¡para evitar posibles daños a la GPIO Hackerboard o a la impresora!

Disparador Remoto por Cable

En primer lugar, vamos a ver cómo conectar una cámara a la GPIO Hackerboard con un cable. Es importante saber que diferentes cámaras requieren diversos métodos para conectar y disparar un obturador remoto. Por ejemplo, algunas pueden requerir un circuito eléctrico con resistencias específicas (como el que construimos para nuestra Panasonic Lumix DC-GH5 en un artículo anterior), o utilizan conectores propietarios. Otros, sin embargo, simplemente requieren contactos de puente en un cable jack estándar de 2.5 mm para disparar una instantánea.

Para esta guía, nos centraremos en esta sencilla solución, utilizando un cable con un conector de 4 polos de 2.5 mm en ambos extremos. Este enfoque elimina cualquier necesidad de soldadura, simplificando todo el proceso y permitiéndole conectar y desconectar fácilmente el circuito según sea necesario.

Primero, conecta la GPIO Hackerboard a tu impresora (no olvides apagarla previamente). A continuación, conecta un extremo del cable jack a la Hackerboard y el otro extremo a tu cámara. Ya puedes volver a encender la impresora.

A continuación, vamos a comprobar qué segmentos del conector jack de 2.5 mm tenemos que puentear para que la cámara haga una foto. A continuación encontrarás un diagrama que ilustra qué conexiones activan el enfoque automático y cuáles activan la instantánea (esto es específico de nuestro modelo de cámara). En este caso, para disparar la instantánea, puentearemos el primer (0) y el último (GND) segmento del conector jack de 2.5 mm. Esto se controlará mediante unas sencillas instrucciones de código G insertadas en PrusaSlicer.

 

Antes de proceder a PrusaSlicer, vamos a configurar rápidamente la cámara para obtener una buena vista de la cama de impresión y asegurar la configuración correcta de la cámara, incluyendo el enfoque. Una vez completados los ajustes, cambia la cámara al modo de enfoque manual.

Abre PrusaSlicer, selecciona tu impresora e importa el modelo que vas a imprimir. Luego, ve a la pestaña Impresoras en el menú superior y selecciona la opción «Código G personalizado» del menú de la izquierda. Si no ves esta opción, cambia PrusaSlicer a modo Experto utilizando el menú desplegable situado en la esquina superior derecha de la pantalla, junto al icono de usuario.

Aquí puedes encontrar comandos de código G que se ejecutan durante cada impresión, independientemente del modelo impreso, ajustes, etc. Esto incluye instrucciones que se ejecutan antes de que comience una impresión, después de que termine, o antes/después de cada cambio de capa, etc. Nos centraremos en las seccionesCódigo G inicial y Código G tras un cambio de capa. En la sección de Código G inicial, pondremos el Pin 0 como salida colocando esta instrucción al final de la sección (el texto después de un punto y coma es un comentario y no influye en el código):

; Set Pin 0 as output
M262 P0 B0

Lo siguiente, en la sección de Código G tras un cambio de capa, activaremos la secuencia de instantáneas. Esto significa que cada vez que se termine una capa impresa, moveremos el cabezal de impresión fuera del camino para asegurar una toma clara y tomaremos una foto. El cabezal de impresión espera un momento y vuelve a su posición original. La impresión continuará hasta el siguiente cambio de capa. De nuevo, colocaremos estas instrucciones al final de la sección:

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

Puedes guardar esta configuración utilizando el icono de guardar del menú superior, para poder cambiar fácilmente entre los perfiles de impresión normal y timelapse.

Ahora, puedes volver a la pestaña Plataforma, pulsar el botón Laminar, y enviar el código G terminado a tu impresora. Una vez que se inicie el proceso de impresión, la cámara se disparará constantemente después de que cada capa esté terminada, proporcionando una toma clara y estabilizada de tu impresión en progreso. Con solo unas pocas líneas de g-code, ¡estás listo para capturar hermosos timelapses capa por capa!

Si todo ha funcionado correctamente, ahora deberías tener muchas fotos fantásticas de la impresión en curso. Ahora, tenemos que convertirlas en un vídeo timelapse. Para ello, vamos a utilizar el excelente software de edición de vídeo, DaVinci Resolve, que está disponible para su descarga gratuita here.

Creando un vídeo Timelapse con DaVinci Resolve

Primero, instala y abre DaVinci Resolve y crea un nuevo proyecto. Antes de hacer cualquier otra cosa, navega a la pestaña Medios, que es el primer icono del menú de la parte inferior de la pantalla. Allí, en el menú superior, haz clic en el botón de tres puntos y asegúrate de que la opción «Modo de visualización de fotograma» está cambiada a «Secuencia». Este ajuste le dice a Resolve que una todas tus fotos importadas en un único clip de vídeo, en lugar de cientos (o incluso miles, para timelapses más largos) de imágenes individuales.

Ahora, cambia a la página Editar. Para importar tus fotos, localízalas en su carpeta en tu ordenador y selecciónalas todas. Con todos los archivos seleccionados, arrástralos y suéltalos en el área Maestra de la parte izquierda de la pantalla. Esto creará automáticamente uno o más clips de secuencia a partir de todas las imágenes. Ahora, arrastra y suelta el clip(s) en tu línea de tiempo. Puedes previsualizar el timelapse generado pulsando el botón de reproducción o arrastrando la línea roja a través de la línea de tiempo. También puedes cambiar la velocidad de fotogramas y aplicar varios efectos de post-procesado a tu vídeo timelapse, como la gradación de color, estabilización de imagen, etc.

El resultado puede ser el siguiente:

Puedes ajustar valores como la posición del cabezal de impresión o los tiempos de espera para adaptarlos a tus necesidades. Sin embargo, ten en cuenta que un tiempo de recorrido más largo aumenta el riesgo de que el filamento rezume de la boquilla caliente. Esto puede causar artefactos de impresión o hilos. Para minimizar este problema, utiliza filamento bien seco y evita ajustar distancias de recorrido excesivamente largas para el cabezal de impresión.

Un Consejo Importante: ¿No Se Combinan Las Imágenes?

Si todavía ves las fotos importadas individualmente, incluso después de haber configurado correctamente el Modo de Visualización de Fotogramas a Secuencia, el problema es probablemente con la nomenclatura de los archivos. DaVinci Resolve necesita una secuencia numérica continua para agrupar correctamente los archivos.

  • Nombre Correcto: P2200553.JPG, P2200554.JPG, P2200555.JPG, etc.
  • Nombre Incorrecto: IMG_45.jpg, Photo_46.jpg, IMG_48.jpg (prefijos incoherente o vacíos en los números).

Antes de importar, asegúrate de que todos sus archivos tienen el mismo prefijo y una secuencia numérica sin espacios.

Ahora que ya sabes cómo crear un vídeo timelapse a partir de una configuración de cámara con cable, vamos a ver un par de opciones más para capturar las fotos. Empezaremos con un disparador remoto inalámbrico para tu cámara digital y luego pasaremos a un método algo más avanzado que utiliza tu smartphone.

Disparador Remoto Inalámbrico

La solución inalámbrica requiere un poco de soldadura, pero es muy fácil, y la configuración del código G es idéntica a la del ejemplo anterior.

Usamos cámaras Sony Alpha, así que hemos comprado un obturador remoto IR inalámbrico Sony de bajo coste. Normalmente, puedes comprar en Internet versiones universales o específicas de este tipo de disparadores remotos, aptas para varias marcas, por unos pocos dólares.

Desmóntalo para acceder a su placa de circuito impreso interna e identificar el par de contactos que se puentean al pulsar el botón de disparo. Mientras que algunos botones tienen varias posiciones para el enfoque y el disparo, este obturador remoto en particular solo dispara la instantánea. Puedes encontrar el cableado correcto observando la PCB o consultando su hoja de datos.

Para la conexión entre el obturador remoto inalámbrico y la GPIO Hackerboard, utilizaremos de nuevo un cable jack de 4 polos de 2.5 mm, pero con una configuración diferente. En lugar de tener un jack en ambos extremos, necesitamos que uno de los extremos tenga cables expuestos que se soldarán a la PCB de la persiana remota. Tienes dos maneras de conseguir este cable: o compras uno prefabricado, o lo haces tú mismo cortando un cable jack-a-jack estándar y pelando cuidadosamente un extremo para dejar al descubierto los cables internos. Utiliza un multímetro para identificar cuál de los cuatro cables corresponde a los segmentos correctos del jack. Utilizaremos los mismos dos contactos que se muestran en el diagrama de la sección anterior: el primer (0) y el último (GND) segmento del conector jack. Una vez que hayas identificado los dos cables correctos, suéldalos a los contactos del botón en la PCB de la persiana remota. Corta los dos cables restantes y vuelve a montar el cuerpo de la persiana remota.

Ahora, conecta GPIO Hackerboard a la impresora y enciéndela. A continuación, conecta el jack de 2.5mm a la toma del GPIO Hackerboard, apunta el mando inalámbrico a tu cámara, e inicia la impresión con la secuencia preparada del código G para timelapse. Al igual que en el ejemplo anterior, la impresora debe detenerse en cada cambio de capa y enviar una señal (inalámbrica) a la cámara para tomar una instantánea.

Para aquellos que busquen una guía visual sobre cómo soldar y utilizar el obturador remoto inalámbrico y la GPIO Hackerboard, Martin Zeman, miembro de la comunidad de impresión 3D, ha elaborado un magnífico vídeo en el que se muestra todo el proceso:

Haciendo Fotos con un Smartphone mediante Bluetooth y ESP32

¿Quieres llevar este proyecto un paso más allá? Puedes utilizar tu smartphone en lugar de una cámara digital. La calidad de imagen es más que suficiente para crear un vídeo timelapse de gran aspecto. Con la GPIO Hackerboard y una pequeña placa ESP32 con conectividad Bluetooth, puedes construir tu propio disparador remoto inalámbrico para tu teléfono.

Para construirlo, además de soldar, tendrás que programar un poco. La configuración es más compleja, ya que implica la creación y carga de código específico para la placa ESP32. La placa maneja la misma señal desde el GPIO Hackerboard, como en el ejemplo anterior. Sin embargo, en lugar de activar los contactos de la cámara digital, envía un comando a tu teléfono a través de Bluetooth, simulando un pulsación del botón de volumen, que suele hacer las veces de disparador de la cámara.

Primero, en la GPIO Hackerboard, puentea los contactos JP7 soldándolos para habilitar la resistencia pull-up integrada. A continuación, suelda las conexiones entre las placas: conecta el contacto GND de la Hackerboard a un pin GND de la placa ESP32, y el contacto OUT 7 al pin D3 (GPIO5) del ESP32.

Vamos a proceder a la parte de software. A continuación, hemos incluido la muestra de código que utilizamos para obtener nuestra placa ESP32 específica en funcionamiento. Considéralo un punto de partida inspirador para tu propio proyecto.

Ten en cuenta lo siguiente: este código se proporciona tal cual y sin ninguna garantía. Es probable que tengas que adaptarlo para que funcione con tu hardware particular.

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

 

Tenemos que subir este código a la placa ESP32 utilizando el software Arduino IDE. La estructura de los menús y los nombres de los elementos pueden variar en función de la versión de la aplicación o de la plataforma que utilices.

En primer lugar, conecta la placa ESP32 al ordenador a través de USB, inicia el IDE de Arduino, e instala el paquete de placa ESP32 navegando a File -> Preferences y pega la siguiente URL en el campo de «Additional Boards Manager URLs»: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

. Después ve a Tools -> Board -> Boards Manager, busca “ESP32”, selecciona la última versión del ESP32, e instálala. Ahora, selecciona el modelo de tu placa en Tools -> Board -> ESP32. Y por último, abre Tools -> Port y selecciona el nombre correcto del puerto serie de la placa conectada.

Ahora, puedes subir el código a tu ESP32. Borra el código generado en el IDE de Arduino y pega el código de arriba. Pulsa el botón Upload (flecha), y espera a que el IDE de Arduino compile y suba el código a la placa.

Si todo está hecho correctamente, intenta buscar el dispositivo Bluetooth llamado “Prusa-Timelapse-Trigger” (o un nombre diferente, si lo has cambiado en el código) y conéctate a él. Para comprobar si hay mensajes de estado en la comunicación serie, ve a Tools -> Serial Monitor.

Ahora puedes probar el disparador simulando la señal de la Hackerboard. Utiliza unas pinzas o un pequeño alambre para conectar brevemente el pin de entrada (D3/GPIO5) de la ESP32 al pin de GND. Deberías ver que el nivel de volumen de tu teléfono cambia. Si es así, ya puedes empezar. Desconecta la ESP32 del ordenador y enciéndela con un adaptador de corriente USB-C estándar. Ahora puedes conectar el GPIO Hackerboard a tu impresora. ¡No olvides apagar la impresora antes de conectar la Hackerboard!

Tenemos que modificar ligeramente el código G en PrusaSlicer, para que active la salida OUT7 en lugar de OUT0. Haremos esto simplemente cambiando el P0 a P7 en las secciones de Código G inicial y Código G tras un cambio de capa. Ahora, cuando inicies la impresión, cada vez que se produzca un cambio de capa, el GPIO Hackerboard enviará una señal a la ESP32, que a su vez enviará un comando para cambiar el volumen de tu teléfono. Si tu aplicación de cámara está activa, esto disparará el obturador y tomará una foto.

Y ya está. Este es solo uno de los muchos casos de uso posibles para el GPIO Hackerboard. Siéntete libre de modificar y mejorar estas soluciones. Estamos deseando ver tus ideas sobre cómo utilizar este pequeño e inteligente módulo. Puedes encontrar instrucciones detalladas para la placa GPIO en nuestra ayuda.

¡Felices impresiones!