Nos imprimantes ont toujours été ouvertes à diverses modifications des utilisateurs, et avec notre Hackerboard GPIO, nous étendons encore plus ces possibilités. Ce module complémentaire optionnel a déjà suscité une attention considérable de la part des utilisateurs qui aiment expérimenter et découvrir de nouvelles façons d’améliorer leurs installations autour de leur Original Prusa MK4/S et Prusa CORE One. Pour ceux qui n’ont pas encore exploré le potentiel du de la Hackerboard GPIO Prusa, nous avons préparé un projet qui l’utilise pour créer une vidéo timelapse de votre impression 3D. Cet exemple met en évidence ce qui est possible et nous espérons qu’il inspirera des idées pour vos propres modifications.

Rapidement, ce projet est conçu pour vous permettre d’utiliser des appareils photo numériques haut de gamme, vous permettant d’obtenir la meilleure qualité d’image possible pour vos timelapses. Cependant, pour ceux qui recherchent une solution plus simple et plus intégrée, nous avons récemment publié une mise à jour du firmware pour nos caméras Buddy3D. Cette mise à jour ajoute la possibilité de capturer des photos pour un timelapse directement avec la caméra Buddy3D elle-même, ce qui peut être une solution parfaite pour de nombreux projets. Consultez notre article sur cette mise à jour importante ici.

ATTENTION : Toutes les modifications et connexions sont effectuées à vos propres risques. Nous n’assumons aucune responsabilité pour les dommages causés à un appareil qui pourraient survenir, par exemple, en raison d’un câblage incorrect, d’une mauvaise manipulation ou du non-respect des instructions.

Timelapse d’une impression avec un appareil photo numérique

Dans l’un de nos articles précédents, nous avons publié un guide détaillé sur la façon dont nous créons nos magnifiques vidéos timelapse à l’aide d’un appareil photo numérique et d’un câble sur mesure connecté directement à la carte mère des imprimantes MK3/S et M2.5/S. Vous pouvez trouver l’article original ici.

Dans cette solution, les broches de la carte mère étaient contrôlées par des instructions G-code, qui activaient une sortie de tension sur celles-ci. Le signal de tension activait ensuite un circuit dans le câble et déclenchait l’obturateur de l’appareil photo. Cette méthode faisait l’affaire, mais elle était assez complexe, car elle nécessitait de connecter les câbles DuPont directement aux broches de la carte mère de l’imprimante, créant ainsi un risque de câblage incorrect. La Hackerboard GPIO fournit une solution similaire, mais plus élégante. Elle est connectée à la carte mère d’une imprimante MK4/S ou CORE One via un simple connecteur I2C, et les instructions G-code activent l’une des huit broches d’E/S de la Hackerboard, vous permettant de contrôler facilement des périphériques externes.

Pour créer des timelapses d’impression 3D, vous pouvez utiliser des déclencheurs à distance filaires et sans fil, en fonction de ce que votre appareil photo prend en charge. La solution préférée est cependant d’utiliser une version sans fil, car elle est complètement isolée de l’électronique et de l’alimentation de l’imprimante, ce qui assure la sécurité de votre appareil photo à tout moment. Nous vous montrerons les deux solutions, afin que vous puissiez choisir celle qui correspond le mieux à vos besoins.

N’oubliez pas : éteignez toujours votre imprimante avant de connecter la Hackerboard GPIO, afin d’éviter d’endommager potentiellement la Hackerboard GPIO ou l’imprimante !

Déclencher à distance filaire

Tout d’abord, examinons la connexion d’une caméra à la Hackerboard GPIO avec un câble. Il est important de savoir que différents appareils photo nécessitent différentes méthodes pour connecter et déclencher un déclencheur à distance. Par exemple, certains peuvent nécessiter un circuit électrique avec des résistances déterminées (comme celui que nous avons construit pour notre Panasonic Lumix DC-GH5 dans un article précédent), ou utiliser des connecteurs spécifiques. D’autres, cependant, nécessitent simplement des contacts de pontage sur un câble jack standard de 2,5 mm pour déclencher une prise de vue.

Pour ce guide, nous nous concentrerons sur cette solution simple, en utilisant un câble avec une prise jack 2,5 mm à 4 pôles aux deux extrémités. Cette approche élimine tout besoin de soudure, simplifiant l’ensemble du processus et vous permettant de connecter et de déconnecter facilement le circuit selon vos besoins.

Tout d’abord, connectez la Hackerboard GPIO à votre imprimante (n’oubliez pas de l’éteindre au préalable). Ensuite, branchez une extrémité du câble jack sur la Hackerboard et l’autre extrémité sur votre appareil photo. Vous pouvez maintenant rallumer l’imprimante.

Ensuite, vérifions quels segments du connecteur jack 2,5 mm nous devons relier pour que l’appareil photo prenne une photo. Vous trouverez ci-dessous un schéma illustrant quelles connexions déclenchent l’autofocus et lesquelles déclenchent la prise de vue (ceci est spécifique à notre modèle d’appareil photo). Dans ce cas, pour déclencher la prise de vue, nous allons relier le premier (0) et le dernier (GND) segment du connecteur jack 2,5 mm. Cela sera contrôlé par quelques instructions G-code simples insérées dans PrusaSlicer.

Avant de passer à PrusaSlicer, configurons rapidement l’appareil photo pour obtenir une bonne vue du plateau d’impression et s’assurer d’avoir les bons réglages pour l’appareil photo, y compris la mise au point. Une fois les réglages terminés, passez l’appareil photo en mode de mise au point manuelle.

Ouvrez PrusaSlicer, sélectionnez votre imprimante et importez le modèle que vous allez imprimer. Ensuite, accédez à l’onglet Imprimantes dans le menu supérieur et sélectionnez l’élément « G-code personnalisé » dans le menu de gauche. Si vous ne voyez pas cette option, passez PrusaSlicer en mode Expert à l’aide du menu déroulant situé dans le coin supérieur droit de l’écran, à côté de l’icône utilisateur.

Vous trouverez ici les commandes G-code qui sont exécutées à chaque impression, quel que soit le modèle imprimé, les réglages, etc. Il s’agit notamment d’instructions qui s’exécutent avant le début d’une impression, après sa fin, ou avant/après chaque changement de couche, etc. Nous nous concentrerons sur les sections G-code de début et G-Code après changement de couche. Dans la section G-code de début, nous allons définir la broche 0 comme sortie en plaçant cette instruction à la toute fin de la section (le texte après un point-virgule est un commentaire et n’influence pas le code) :

; Set Pin 0 as output
M262 P0 B0

Ensuite, dans la section G-code après le changement de couche, nous déclencherons la séquence de prise de vue elle-même. Cela signifie qu’à chaque fois qu’une couche imprimée est terminée, nous déplacerons la tête d’impression pour garantir une prise de vue claire et prendre une photo. La tête d’impression attend un instant puis revient à sa position d’origine. L’impression continuera jusqu’au prochain changement de couche. Encore une fois, nous placerons ces instructions à la toute fin de la section :

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

Vous pouvez enregistrer cette configuration à l’aide de l’icône Enregistrer dans le menu supérieur, afin de pouvoir facilement basculer entre les profils d’impression normaux et timelapse.

Vous pouvez maintenant revenir à l’onglet Plateau, appuyer sur le bouton Découper et envoyer le G-code terminé à votre imprimante. Une fois le processus d’impression lancé, l’appareil photo se déclenche systématiquement une fois chaque couche terminée, offrant ainsi une image claire et stabilisée de votre impression en cours. Avec seulement quelques lignes de G-code, vous êtes prêt à capturer de magnifiques timelapses couche par couche !

Si tout s’est bien passé, vous devriez maintenant avoir de nombreuses superbes photos de l’impression en cours. Maintenant, nous devons les transformer en une vidéo timelapse. Pour cela, nous utiliserons l’excellent logiciel de montage vidéo, DaVinci Resolve, disponible en téléchargement gratuit ici.

Création d’une vidéo timelapse avec DaVinci Resolve

Tout d’abord, installez et ouvrez DaVinci Resolve et créez un nouveau projet. Avant de faire quoi que ce soit d’autre, accédez à l’onglet Médias, qui est la première icône du menu en bas de l’écran. Là, dans le menu supérieur, cliquez sur le bouton à trois points et assurez-vous que l’option « Mode d’affichage des images » est configuré sur « Séquence ». Ce paramètre indique à Resolve d’unir toutes vos photos importées dans un seul clip vidéo, plutôt que des centaines (voire des milliers, pour des timelapses plus longs) d’images individuelles.

Passez maintenant à la page Éditer. Pour importer vos photos, localisez-les dans leur dossier sur votre ordinateur et sélectionnez-les toutes. Une fois tous les fichiers sélectionnés, faites un glisser-déposer dans la zone principale sur le côté gauche de l’écran. Cela créera automatiquement un ou plusieurs clips de séquence à partir de toutes les images. Maintenant, faites glisser et déposez le(s) clip(s) dans votre chronologie. Vous pouvez prévisualiser le timelapse généré en appuyant sur le bouton de lecture ou en faisant glisser la ligne rouge sur la chronologie. Vous pouvez également modifier la fréquence d’images et appliquer divers effets de post-traitement à votre vidéo timelapse, tels que l’étalonnage des couleurs, la stabilisation d’image, etc.

Votre résultat peut ressembler à ceci :

Vous pouvez ajuster les valeurs dans les instructions du G-code, telles que la position de la tête d’impression ou les temps d’attente en fonction de vos besoins. Cependant, gardez à l’esprit que le temps de trajet plus long augmente le risque de suintement du filament de la buse chaude. Cela peut potentiellement provoquer des artefacts d’impression ou des cheveux d’ange. Pour minimiser ce problème, utilisez un filament bien séché et évitez de définir des distances de déplacement excessivement longues pour la tête d’impression.

Maintenant que vous savez comment créer une vidéo timelapse à partir d’une installation d’appareil photo filaire, examinons quelques autres options pour capturer les photos. Nous commencerons par un déclencheur à distance sans fil pour votre appareil photo numérique, puis passerons à une méthode légèrement plus avancée qui utilise votre smartphone.

Déclencheur à distance sans fil

La solution sans fil nécessite un peu de soudure, mais elle est très simple et la configuration du G-code est identique à l’exemple précédent.

Nous utilisons des appareils photo Sony Alpha, nous avons donc acheté un déclencheur infrarouge sans fil Sony bon marché. Vous pouvez généralement commander en ligne des versions spécifiques à une marque ou universelles de ces déclencheurs à distance, adaptées à plusieurs marques, pour seulement quelques dollars.

Démontez-le pour accéder à son PCB interne et identifier la paire de contacts qui sont pontés lorsque le bouton de déclenchement est enfoncé. Alors que certains boutons ont plusieurs positions pour la mise au point et le déclenchement, ce déclencheur à distance particulier déclenche uniquement la prise de vue. Vous pouvez trouver le bon câblage en observant le PCB ou en consultant sa fiche technique.

Pour la connexion entre le déclencheur à distance sans fil et la Hackerboard GPIO, nous utiliserons à nouveau un câble jack 4 pôles 2,5 mm, mais dans une configuration différente. Au lieu d’avoir une prise jack aux deux extrémités, nous avons besoin qu’une extrémité ait des fils exposés qui seront soudés au PCB du déclencheur à distance. Vous avez deux façons de vous procurer ce câble : soit vous en achetez un préfabriqué, soit vous le fabriquez vous-même en coupant un câble jack-jack standard et en dénudant soigneusement une extrémité pour exposer les fils internes. Utilisez un multimètre pour identifier lequel des quatre fils correspond aux bons segments de la prise. Nous utiliserons les deux mêmes contacts que ceux indiqués dans le schéma de la section précédente : le premier (0) et le dernier (GND) segments du connecteur jack. Une fois que vous avez identifié les deux bons fils, soudez-les aux contacts du bouton sur le PCB du déclencheur à distance. Coupez les deux fils restants et réassemblez le corps du déclencheur à distance.

Maintenant, connectez la Hackerboard GPIO à l’imprimante et allumez-la. Ensuite, branchez la prise jack 2,5 mm sur la prise de la Hackerboard GPIO, pointez la télécommande sans fil vers votre appareil photo et démarrez l’impression avec la séquence de G-code de début de timelapse préparée. Tout comme dans l’exemple précédent, l’imprimante doit s’arrêter à chaque changement de couche et envoyer un signal (sans fil) à l’appareil photo pour réaliser une prise de vue.

Pour ceux qui recherchent un guide visuel sur la soudure et l’utilisation du déclencheur à distance sans fil et de la Hackerboard GPIO, Martin Zeman, membre de la communauté de l’impression 3D, a réalisé une superbe vidéo présentant l’ensemble du processus :

Prise de photos avec un smartphone via Bluetooth et ESP32

Vous souhaitez pousser ce projet un peu plus loin ? Vous pouvez utiliser votre smartphone au lieu d’un appareil photo numérique. La qualité de l’image est plus que suffisante pour créer une superbe vidéo timelapse. Avec la Hackerboard GPIO et une petite carte ESP32 avec connectivité Bluetooth, vous pouvez créer votre propre déclencheur à distance sans fil pour votre téléphone.

Pour construire cela, en plus de la soudure, vous devrez également faire un peu de programmation. La configuration est plus complexe, car elle implique la création et le téléchargement d’un code spécifique sur la carte ESP32. La carte gère le même signal de la Hackerboard GPIO, comme dans l’exemple précédent. Cependant, au lieu de déclencher les contacts de l’appareil photo numérique, il envoie une commande à votre téléphone via Bluetooth, simulant un appui sur le bouton de volume, qui sert généralement de bouton de déclencheur de l’appareil photo.

Tout d’abord, sur la Hackerboard GPIO, reliez les contacts JP7 en les soudant pour activer la résistance de pull-up intégrée. Soudez ensuite les connexions entre les cartes : connectez le contact GND de la Hackerboard à une broche GND de la carte ESP32, et le contact OUT 7 à la broche D3 (GPIO5) de l’ESP32.

Passons maintenant au côté logiciel. Ci-dessous, nous avons inclus l’exemple de code que nous avons utilisé pour faire fonctionner notre carte ESP32 spécifique. Considérez-le comme un point de départ inspirant pour votre propre projet.

Veuillez noter : ce code est fourni tel quel et sans aucune garantie. Vous devrez probablement l’adapter pour qu’il fonctionne avec votre matériel particulier.

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

Nous devons télécharger ce code sur la carte ESP32 à l’aide du logiciel Arduino IDE. La structure du menu et les noms des éléments peuvent varier en fonction de la version de l’application ou de la plate-forme que vous utilisez.

Tout d’abord, connectez la carte ESP32 à l’ordinateur via USB, démarrez l’IDE Arduino et installez le package de la carte ESP32 en accédant à Fichier -> Préférences et en collant l’URL suivante dans le champ « URL du gestionnaire de cartes supplémentaires » : https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json. Ensuite, allez dans Outils -> Carte -> Gestionnaire de cartes, recherchez « ESP32 », sélectionnez la dernière version de l’ESP32 et installez-la. Sélectionnez maintenant votre modèle de carte dans Outils -> Carte -> ESP32. Enfin, ouvrez Outils -> Port et sélectionnez le nom du port série de la carte connectée.

Vous pouvez maintenant télécharger le code sur votre ESP32. Supprimez le code généré dans l’IDE Arduino et collez le code ci-dessus. Appuyez sur le bouton Télécharger (flèche) et attendez que l’IDE Arduino compile et télécharge le code sur la carte.

Si tout est fait correctement, essayez de rechercher le périphérique Bluetooth nommé « Prusa-Timelapse-Trigger » (ou un nom différent, si vous l’avez modifié dans le code) et connectez-vous-y. Pour vérifier les messages d’état dans la communication série, accédez à Outils -> Moniteur série.

Vous pouvez maintenant tester le déclencheur en simulant le signal de la Hackerboard. Utilisez une pince à épiler ou un petit fil pour connecter brièvement la broche d’entrée de l’ESP32 (D3/GPIO5) à une broche GND. Vous devriez voir le niveau de volume sur votre téléphone changer. Si c’est le cas, vous pouvez continuer. Déconnectez l’ESP32 de votre ordinateur et alimentez-la avec un adaptateur secteur USB-C standard. Vous pouvez maintenant connecter la Hackerboard GPIO à votre imprimante. N’oubliez pas d’éteindre l’imprimante avant de connecter la Hackerboard !

Nous devons légèrement modifier le G-code dans PrusaSlicer, afin qu’il déclenche la sortie OUT7 au lieu de la sortie OUT0. Nous le ferons en changeant simplement le P0 en P7 dans les sections de G-code de début et de G-code de début après changement de couche. Désormais, lorsque vous lancez l’impression, chaque fois qu’un changement de couche se produit, la Hackerboard GPIO enverra un signal à l’ESP32, qui enverra alors une commande pour modifier le volume sur votre téléphone. Si votre application appareil photo est active, cela déclenchera l’obturateur et prendra une photo.

Et c’est tout ! Ce n’est qu’un des nombreux cas d’utilisation possibles de la Hackerboard GPIO. N’hésitez pas à modifier et améliorer ces solutions. Nous attendons avec impatience de voir vos idées sur la façon d’utiliser ce petit module intelligent. Des instructions détaillées pour la carte GPIO sont disponibles sur notre aide.

Bonne impression !