Étant passionné de domotique, je compte beaucoup sur l’éclairage intelligent. Mais lorsque j’ai eu besoin d’équiper chaque pièce de la maison d’un contrôleur d’éclairage, voire plusieurs, je me suis heurté à un problème de budget. Les contrôleurs intelligents commerciaux sont assez chers. J’ai donc décidé d’utiliser une imprimante 3D, d’ajouter quelques composants électroniques et de construire un contrôleur personnalisé sympa pour une fraction du prix.

J’ai conçu un petit pavé de macro qui utilise des switches de clavier mécanique, une carte ESP32, un encodeur rotatif pour le réglage de la luminosité et un écran OLED compact pour afficher la scène lumineuse active. L’encodeur rotatif est également doté d’un interrupteur à pression intégré : une simple pression active le mode de gradation de l’écran pour ajuster la luminosité de l’écran OLED, et un nouveau clic permet de revenir au contrôle de la lumière normal.

Pour être sûr que ce soit plus qu’une simple boîte en plastique ennuyeuse, j’ai décidé de combiner plusieurs matériaux Prusament Woodfill pour créer de jolies combinaisons de couleurs qui s’harmonisent avec le plateau en bois de mon bureau. J’ai eu la chance de tester l’une des unités bêta de la Prusa CORE One+ INDX, j’ai donc profité de ses capacités multi-matériaux. Cependant, vous pouvez facilement imprimer ce projet sur une Original Prusa XL, une imprimante équipée du MMU3 ou même une machine standard mono-outil sans aucune capacité multi-matériaux. Dans ce cas, vous devrez changer manuellement les filaments à plusieurs reprises pendant l’impression, mais c’est tout à fait faisable – même s’il faut s’attendre à plus de déchets. Grâce à l’utilisation de l’INDX, j’ai quasiment zéro déchet de filament, un avantage considérable pour le projet, car j’ai économisé du matériau que je peux maintenant utiliser pour imprimer des pavés de macro supplémentaires ou d’autres choses.

Matériel

Pour que ce projet reste accessible, toutes les pièces électroniques peuvent être achetées pour quelques euros seulement. Vous pouvez bien sûr omettre l’écran et l’encodeur et ne conserver que les interrupteurs, voire réduire le nombre de touches.

Pour le cerveau du pavé de macro, vous pouvez utiliser presque n’importe quelle carte de développement ESP32 ou similaire disposant d’un nombre suffisant d’entrées et d’une connexion Wi-Fi. Des cartes de haute qualité de marques comme Adafruit (comme la compacte QT Py ESP32-S3 ou la classique Feather ESP32-S3) ou SparkFun (les Thing Plus ESP32-S3) sont des choix parfaits pour cela. Dans mon cas, avant de faire des achats en ligne, j’ai fouillé dans mon tiroir sans fin de pièces détachées et j’ai trouvé une carte similaire, une Xiao ESP32-C3 de Seeed Studio, j’ai donc décidé de l’utiliser pour ce projet.

En ce qui concerne les touches, j’ai opté pour des switches mécaniques bleus. Cela est peut-être un peu spécifique, et des switches standards feraient parfaitement l’affaire, mais l’utilisation de switches mécaniques me convient parfaitement à cause de cette sensation et ce son de clic satisfaisants.

Voici un bref aperçu de ce dont vous aurez besoin pour la version présentée dans cet article :

Impression 3D & personnalisation du design

Il est maintenant temps de préparer les modèles 3D pour l’impression. Vous pouvez les créer vous-même dans un logiciel de modélisation 3D tel que Fusion, ou télécharger les fichiers finaux pour ce projet depuis Printables.

Importez les fichiers dans PrusaSlicer. Pour un aspect épuré et élégant, vous pouvez imprimer un châssis monochrome en utilisant du Prusament Woodfill Linden Light. Cependant, l’imagination n’ayant pas de limites, vous pouvez aussi préparer des variantes très colorées, parfaites pour une chambre d’enfant, comme un style sur le thème des Avengers. Ensuite, ajoutez des modificateurs SVG avec des symboles simples aux touches et au bouton rotatif en cliquant avec le bouton droit sur le modèle dans PrusaSlicer et en sélectionnant Ajouter un modificateur > SVG. Si vous souhaitez un guide plus détaillé sur l’application des modificateurs SVG, consultez notre article sur les accessoires de jeu sensoriel DIY. Choisir un Prusament Chocolate Brown Woodfill plus foncé pour les boutons et utiliser le même Linden Light lumineux pour les symboles crée un très joli contraste. Grâce à l’impression multi-matériaux sur des imprimantes telles que la Prusa CORE One+ INDX ou l’Original Prusa XL, le résultat est d’une précision incroyable, sans aucune contamination des couleurs et avec un minimum absolu de déchets. La meilleure façon d’imprimer les touches est de les placer face contre le plateau. Sur l’image ci-dessous, elles sont retournées face visible uniquement pour illustrer les motifs SVG. Une fois toutes les pièces imprimées, il est temps de passer à l’assemblage.

Assemblage & Câblage

D’abord, installez les switches de clavier mécanique en les poussant simplement à travers les ouvertures du châssis jusqu’à ce qu’ils s’enclenchent. Installez ensuite l’écran, l’encodeur rotatif et l’ESP32, en insérant son connecteur USB-C dans l’ouverture prévue à cet effet sur le côté du châssis, de manière à ce qu’il soit orienté vers l’extérieur. Bien que l’écran et l’encodeur tiennent parfaitement en place individuellement, la fixation de l’ESP32 nécessite un peu plus d’attention. J’ai utilisé une simple entretoise imprimée qu’il suffit de glisser entre la paroi du châssis et la carte pour la caler en place, garantissant ainsi que l’ESP32 ne recule pas lorsque vous branchez le câble USB-C.

Le montage occupe un total de onze broches : six interrupteurs, l’encodeur (2 broches pour la rotation, 1 pour l’interrupteur) et l’afficheur I2C (2 broches pour les données/l’horloge). Cela correspond parfaitement au nombre d’entrées numériques disponibles sur ma carte ESP32. Ci-dessous figure le schéma de câblage créé dans Wokwi, un excellent simulateur gratuit qui fonctionne directement dans votre navigateur. Wokwi intègre également un simulateur, vous permettant de connecter tous les composants et d’écrire du code de test pour vous assurer que votre câblage est correct avant d’assembler l’unité physique.

Soyez prudent lorsque vous regardez la carte : l’étiquette physique imprimée sur le PCB (D0-D10) diffère presque toujours des registres internes (GPIO) utilisés dans le code. Voici le mappage matériel de mon ESP32 :

5V / 5V0 – VCC (Alimentation commune à l’écran OLED et à l’encodeur rotatif)

GND – GND (Masse commune à tous les composants et toutes les touches mécaniques)

D0 (GPIO interne 2) – Touche 1

D1 (GPIO interne 3) – Touche 2

D2 (GPIO interne 4) – Touche 3

D3 (GPIO interne 5) – Touche 4

D4 (GPIO interne 6) – SDA de l’OLED (Ligne des données)

D5 (GPIO interne 7) – SCL de l’OLED (Ligne de l’horloge)

D6 (GPIO interne 21) – CLK de l’encodeur (Broche de rotation A)

D7 (GPIO interne 20) – DT de l’encodeur (Broche de rotation B)

D8 (GPIO interne 8) – SW de l’encodeur (Bouton intégré de l’encodeur)

D9 (GPIO interne 9) – Touche 5

D10 (GPIO interne 10) – Touche 6

Pour les tests initiaux, vous pouvez tout connecter à l’aide de connecteurs Dupont, comme je l’ai fait. Cependant, l’espace à l’intérieur du châssis est restreint, et ces connecteurs ne sont pas suffisamment sûrs pour un usage quotidien. Pour garantir une fiabilité à 100% et un ajustement parfait, je recommande fortement de souder tous les éléments en place.

Configuration logicielle (ESPHome)

Maintenant que tout est branché, c’est l’heure du (vibe) codage 😎 ! Connecter l’ESP32 à un PC ou un Mac est facile. Il suffit de le brancher à votre ordinateur à l’aide d’un câble USB-C, de télécharger les outils nécessaires et de télécharger le code sur la carte via le terminal. Sur Mac, vous pouvez utiliser Python et son paquet ESPHome, installé à l’aide du gestionnaire de paquets Python pip via la commande pip3 installer esphome.

Une fois l’installation terminée, créez deux fichiers YAML : keyboard.yaml et secrets.yaml. Le keyboard.yaml contient tout le code pour l’ESP32, et le secrets.yaml stocke vos identifiants Wi-Fi en toute sécurité. Vous aurez également besoin d’un fichier de police. Dans ce projet, j’ai utilisé la police Nunito provenant de la bibliothèque Google Fonts. Vous pouvez la trouver ici : https://fonts.google.com/specimen/Nunito. Téléchargez et extrayez le fichier, placez la police standard (Nunito-Regular.ttf) dans le même dossier que les autres fichiers et renommez-la en font.ttf.

Remarque : ce code est spécifiquement conçu pour la carte Seeed Studio XIAO ESP32-C3. Si vous utilisez une autre carte ESP32, vous devrez le paramètre board et l’attribution des broches GPIO pour correspondre à votre matériel spécifique. Si vous ne savez pas comment faire, n’hésitez pas à demander de l’aide à votre assistant IA préféré ! 🙂

Voici le fichier keyboard.yaml complet. Ne vous laissez pas intimider par les longs passages marqués comme lambda :. Ces éléments gèrent la logique en arrière-plan, comme la conversion des données de luminosité brutes en pourcentages nets (%) et la mise en forme du texte sur l’écran OLED.

esphome:
  name: keyboard
  on_boot:
    priority: -100
    then:
      - sensor.rotary_encoder.set_value:
          id: rotary_knob
          value: 10
      - sensor.template.publish:
          id: ha_knob
          state: 10
      - binary_sensor.template.publish:
          id: ha_service_mode
          state: false

esp32:
  board: seeed_xiao_esp32c3

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

captive_portal:

api:
  on_client_connected:
    - lambda: |-
        id(ha_service_mode).publish_state(id(service_mode));
        id(ha_active_key_sensor).publish_state(id(active_text));
  services:
    - service: set_display_text
      variables:
        new_text: string
      then:
        - lambda: |-
            id(active_text) = new_text;
            id(ha_active_key_sensor).publish_state(new_text);
            id(oled_display).update();

logger:
  baud_rate: 115200

i2c:
  sda: 6
  scl: 7

globals:
  - id: active_text
    type: std::string
    initial_value: '"OFF"'
  - id: service_mode
    type: bool
    initial_value: 'false'
  - id: saved_light_steps
    type: int
    initial_value: '10'
  - id: display_steps
    type: int
    initial_value: '10'

script:
  - id: block_feedback_script
    mode: restart
    then:
      - delay: 800ms

font:
  - file: "font.ttf"
    id: font_large
    size: 14
  - file: "font.ttf"
    id: font_sub
    size: 10

text_sensor:
  - platform: template
    name: "Active Key"
    id: ha_active_key_sensor

sensor:
  - platform: template
    name: "Rotary Knob"
    id: ha_knob

  - platform: rotary_encoder
    id: rotary_knob
    pin_a: 21
    pin_b: 20
    min_value: 0
    max_value: 10
    resolution: 2
    on_value:
      then:
        - lambda: |-
            if (isnan(x)) return;
            if (id(service_mode)) {
              if (x == 0) id(rotary_knob).set_value(1);
              id(oled_display).set_contrast(id(rotary_knob).state / 10.0);
            } else {
              if (x == 0 and id(ha_light_state).state) id(rotary_knob).set_value(1);
              id(block_feedback_script).execute();
              id(ha_knob).publish_state(id(rotary_knob).state);
            }
        - component.update: oled_display

  - platform: homeassistant
    id: ha_light_brightness
    entity_id: light.office
    attribute: brightness
    on_value:
      then:
        - lambda: |-
            if (not id(service_mode) and not id(block_feedback_script).is_running() and not isnan(x)) {
              int steps = round((x / 255.0) * 10.0);
              id(rotary_knob).set_value(steps);
              id(ha_knob).publish_state(steps);
            }
        - component.update: oled_display

binary_sensor:
  - platform: template
    name: "Service Mode"
    id: ha_service_mode

  - platform: status
    id: ha_connection_status

  - platform: homeassistant
    id: ha_light_state
    entity_id: light.office
    filters:
      - delayed_off: 500ms
    on_state:
      then:
        - lambda: |-
            if (not x) {
              if (not id(service_mode)) {
                id(rotary_knob).set_value(0);
                id(ha_knob).publish_state(0);
              } else {
                id(saved_light_steps) = 0;
              }
              id(active_text) = "OFF";
              id(ha_active_key_sensor).publish_state("OFF");
              id(oled_display).update();
            }

  - platform: gpio
    name: "Encoder Press"
    pin: {number: 8, mode: INPUT_PULLUP, inverted: true}
    on_press:
      then:
        - lambda: |-
            float current_state = isnan(id(rotary_knob).state) ? 10.0 : id(rotary_knob).state;
            if (not id(service_mode)) {
              id(saved_light_steps) = (int)current_state;
              id(service_mode) = true;
              id(rotary_knob).set_value(id(display_steps));
              id(ha_service_mode).publish_state(true);
            } else {
              id(display_steps) = (int)current_state;
              id(service_mode) = false;
              id(rotary_knob).set_value(id(saved_light_steps));
              id(ha_knob).publish_state(id(saved_light_steps));
              id(ha_service_mode).publish_state(false);
            }
        - component.update: oled_display

  - platform: gpio
    name: "Key 1"
    pin: {number: 2, mode: INPUT_PULLUP, inverted: true}
  - platform: gpio
    name: "Key 2"
    pin: {number: 3, mode: INPUT_PULLUP, inverted: true}
  - platform: gpio
    name: "Key 3"
    pin: {number: 4, mode: INPUT_PULLUP, inverted: true}
  - platform: gpio
    name: "Key 4"
    pin: {number: 5, mode: INPUT_PULLUP, inverted: true}
  - platform: gpio
    name: "Key 5"
    pin: {number: 9, mode: INPUT_PULLUP, inverted: true}
  - platform: gpio
    name: "Key 6"
    pin: {number: 10, mode: INPUT_PULLUP, inverted: true}

display:
  - platform: ssd1306_i2c
    id: oled_display
    model: "SSD1306 128x32"
    address: 0x3C
    rotation: 180
    lambda: |-
      if (id(service_mode)) {
        it.print(0, 0, id(font_large), "DISPLAY");
      } else {
        it.print(0, 0, id(font_large), id(active_text).c_str());
      }
      
      if (id(ha_connection_status).state) {
        it.print(82, 0, id(font_sub), "HA: OK");
      } else {
        it.print(82, 0, id(font_sub), "HA: --");
      }
      
      it.printf(0, 19, id(font_sub), "Int: %.0f%%", isnan(id(rotary_knob).state) ? 0.0 : id(rotary_knob).state * 10.0);
      
      if (wifi::global_wifi_component->is_connected()) {
        it.print(75, 19, id(font_sub), "Wi-Fi: OK");
      } else {
        it.print(75, 19, id(font_sub), "Wi-Fi: --");
      }

Le mot de passe du Wi-Fi se trouve dans un fichier séparé secrets.yaml. Créez-le et modifiez-le avec vos propres identifiants :

wifi_ssid: "mon_wi-fi"
wifi_password: "mon_mot_de_passe_secret"

Vous pouvez maintenant compiler et télécharger le code sur votre ESP32 à l’aide de la commande python3 -m esphome run keyboard.yaml. N’oubliez pas que vous devrez exécuter cette commande depuis le dossier où se trouve votre fichier YAML. Lorsque le terminal vous y invite, saisissez le numéro correspondant à votre port USB connecté et appuyez sur Entrée. Si tout a été téléchargé avec succès, vous devriez voir le journal de communication entre votre ordinateur et l’ESP32 dans le terminal, et l’écran devrait s’allumer.

L’écran affiche notamment des informations sur l’état de la connexion Wi-Fi, qui devrait afficher « OK » après quelques secondes. Vous verrez également une ligne « HA » à l’écran, qui représente l’état de la connexion à Home Assistant. Vous n’avez pas à vous soucier de ce statut pour le moment. Dès que nous aurons tout configuré dans HA, elle devrait également afficher « OK ». Si vous voyez les journaux et que l’écran affiche les informations, vous avez flashé l’ESP32 avec succès et vous pouvez passer à la configuration de Home Assistant. Vous pouvez laisser l’ESP32 connecté à un port USB de votre ordinateur ou utiliser n’importe quel adaptateur secteur USB 5V standard pour alimenter le pavé de macro.

Configuration de Home Assistant

1. Ajout de l’ESP32 à Home Assistant

Grâce à l’intégration native d’ESPHome, Home Assistant devrait reconnaître automatiquement votre nouveau pavé de macro.

• Naviguez vers Paramètres > Appareils et Services dans votre tableau de bord Home Assistant.
• Regardez en haut de l’onglet Intégrations. Vous devriez voir un appareil ESPHome nouvellement découvert nommé keyboard.
• Cliquez sur Ajouter et suivez ensuite les instructions à l’écran pour l’ajouter à votre configuration.
• Remarque : S’il n’apparaît pas automatiquement, cliquez sur Ajouter une intégration dans le coin inférieur droit, recherchez ESPHome, et saisissez l’adresse IP locale de votre ESP32.

Une fois ajouté, Home Assistant charge automatiquement toutes vos touches mécaniques, l’encodeur rotatif et le bouton de mode de service.

2. Création de l’entrée de groupe de lumières

Pour que ce projet reste élégant et universel, nous voulons éviter d’intégrer directement dans le code des ampoules intelligentes physiques spécifiques. Créez plutôt une entrée de groupe de lumières. Ainsi, si vous remplacez vos ampoules, il vous suffira de mettre à jour ce groupe, et votre automatisation restera totalement intacte.

• Allez dans Paramètres > Appareils et services et cliquez sur l’onglet Entrées en haut.
• Cliquez sur + Créer une entrée dans le coin inférieur droit.
• Faites défiler vers le bas, sélectionnez Groupe, puis choisissez Groupe de lumières.
• Nommez l’entrée Bureau (ceci générera automatiquement l’ID d’entité requis : light.bureau).
• Sous Membres, sélectionnez les ampoules connectées physiques que vous souhaitez que le pavé de macro contrôle.
• Cliquez Valider / Créer.

Avec le pavé de macro connecté et notre groupe d’éclairage prêt, nous pouvons maintenant tout relier grâce à notre script d’automatisation principal.

• Allez dans Paramètres > Automatisations et scènes et cliquez sur Créer une automatisation.
• Sélectionnez Créer une nouvelle automatisation, puis cliquez sur les trois points dans le coin supérieur droit et choisissez Modifier en YAML.
• Effacez tout code par défaut, collez le script ci-dessous et cliquez sur Enregistrer.

Pour ce guide, j’ai configuré les six touches mécaniques pour activer des scènes de couleurs simples (bleu, vert, rouge, etc.), mais vous pouvez les personnaliser pour déclencher n’importe quelle scène, simple ou avancée.

alias: Light Office - Master Control
description: Master Control for Macropad
triggers:
  - entity_id: binary_sensor.keyboard_key_1
    to: "on"
    id: press_k1
    trigger: state
  - entity_id: binary_sensor.keyboard_key_2
    to: "on"
    id: press_k2
    trigger: state
  - entity_id: binary_sensor.keyboard_key_3
    to: "on"
    id: press_k3
    trigger: state
  - entity_id: binary_sensor.keyboard_key_4
    to: "on"
    id: press_k4
    trigger: state
  - entity_id: binary_sensor.keyboard_key_5
    to: "on"
    id: press_k5
    trigger: state
  - entity_id: binary_sensor.keyboard_key_6
    to: "on"
    id: press_k6
    trigger: state
  - entity_id: sensor.keyboard_rotary_knob
    id: knob_rotation
    trigger: state
conditions:
  - condition: state
    entity_id: binary_sensor.keyboard_service_mode
    state: "off"
actions:
  - choose:
      - conditions:
          - condition: trigger
            id: knob_rotation
        sequence:
          - action: light.turn_on
            metadata: {}
            target:
              entity_id: light.office
            data:
              brightness_pct: "{{ (trigger.to_state.state | int(10)) * 10 }}"
      - conditions:
          - condition: trigger
            id: press_k1
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: Blue
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 4
                    - 51
                    - 255
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: Blue
      - conditions:
          - condition: trigger
            id: press_k2
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: Green
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 0
                    - 249
                    - 0
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: Green
      - conditions:
          - condition: trigger
            id: press_k3
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: Red
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 255
                    - 0
                    - 0
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: Red
      - conditions:
          - condition: trigger
            id: press_k4
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: Yellow
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 255
                    - 255
                    - 0
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: Yellow
      - conditions:
          - condition: trigger
            id: press_k5
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: Purple
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 255
                    - 0
                    - 255
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: Purple
      - conditions:
          - condition: trigger
            id: press_k6
        sequence:
          - choose:
              - conditions:
                  - condition: state
                    entity_id: sensor.keyboard_active_key
                    state: White
                sequence:
                  - action: light.turn_off
                    target:
                      entity_id: light.office
            default:
              - action: light.turn_on
                target:
                  entity_id: light.office
                data:
                  brightness_pct: 100
                  rgb_color:
                    - 255
                    - 255
                    - 255
              - action: esphome.keyboard_set_display_text
                data:
                  new_text: White
mode: restart

L’éditeur YAML de Home Assistant ressemble à ceci :

Tests et conclusion

Une fois tout téléchargé, il est temps de tester le pavé de macro. Appuyez sur une touche, et l’ambiance lumineuse devrait changer immédiatement. Tournez l’encodeur rotatif et l’intensité lumineuse changera. L’écran OLED doit également afficher correctement la scène actuellement sélectionnée.

Si tout fonctionne parfaitement, il ne reste plus qu’à imprimer le capot inférieur et à l’emboîter. Grâce à sa conception à emboîtement par friction, il tient parfaitement en place sans colle ni vis. Comme j’avais câblé ma version de test avec des connecteurs Dupont encombrants, j’avais besoin d’un peu plus d’espace à l’intérieur, j’ai donc fabriqué une pièce inférieure légèrement plus haute. L’avantage, c’est que j’en ai profité pour mélanger à nouveau différents matériaux Prusament Woodfill pour créer une jolie bande de transition. Si vous décidez de souder vos composants, vous pouvez affiner le capot inférieur pour réduire considérablement la hauteur du pavé de macro.

Bien que j’utilise ce pavé de macro uniquement pour contrôler l’éclairage, vous pouvez l’associer à n’importe quelle fonctionnalité de maison connectée. Grâce à Home Assistant qui gère la logique, une simple pression sur une touche ou une rotation d’encodeur peut régler les stores, démarrer un aspirateur robot ou déclencher une automatisation Spotify pour impressionner vos invités. Il n’y a pas de limites ! Et une fois que vous aurez réalisé votre premier projet de ce type, il sera difficile de ne pas chercher dans la maison d’autres endroits où une imprimante 3D et quelques composants électroniques pourraient s’avérer utiles.

Bonne impression !