Controleur fait maison - log 1

Création de contrôleurs personnalisés pour l'événement JAIMEJAIME, utilisant des microcontrôleurs abordables et CircuitPython pour l'accessibilité et simplicité d'utilisation.

· 6 minutes de lecture

Ceci n'est pas un tutoriel.

Je continue la préparation de la première édition de JAIMEJAIME et je souhaite créer des petits contrôleurs sur mesure pour servir d'interfaces aux jeux présents lors de l'événement. Certains contrôleurs seront ultra minimalistes, avec une seule touche, tandis que d'autres seront plus complexes.

Il existe de nombreuses vidéos sur la fabrication de claviers maison, certaines plus complexes que les autres, avec des niveaux de finition qui varient considérablement.

Voici quelques ressources sur le sujet :

Big Key Switches Macro Pad by adafruit
Video https://youtu.be/y5g3rD29SMQ Guide: https://learn.adafruit.com/big-key-switch Build a Giant MacroPad with Big Key Switches, CircuitPython and the KB2040! Regular key switches are fairly small in size but these novelty ones are about 64 times as big! This is powered by the KB2040 Kee Boar Driver running CircuitPython. It’s an Ardunio Pro micro-shaped board that’s perfect for keyboard projects. Learn Guidehttps://learn.adafruit.com/big-key-switch/ KB2040https://www.adafruit.com/product/5302 Big Key Switchhttps://www.adafruit.com/product/5307 10mm LEDshttps://www.adafruit.com/product/4204
Hand-Wiring Guide | QMK Firmware
Documentation for QMK Firmware

J'ai plusieurs contraintes. Je cherche à créer une interface unique qui soit accessible, au minimum, aux personnes en fauteuil roulant, tout en utilisant des ressources limitées. Grâce à Labomedia, j'ai accès à une découpeuse laser et à une imprimante 3D.

L'objectif n'est pas nécessairement de proposer un contrôleur alternatif unique, mais plutôt de créer une interface simple qui embellit visuellement l'espace et facilite l'interaction. Ceci est particulièrement important pour un public peu habitué aux pratiques de jeux expérimentales, qui ont rarement des tutoriels clairs et adaptés, tout en respectant les nouvelles normes de jeu. Aujourd'hui, les touches d'un clavier sont beaucoup plus populaires que les joysticks et boutons de bornes d'arcade.

J'ai déjà tenté de moderniser la borne d'arcade et de l'adapter aux jeux vidéo d'auteur (à l'exception de la question de l'accessibilité) lors du premier festival du PangPangClub, il y a quelques années.

1- les Switch

Le switch est le bouton lui-même. Il existe différents formats et qualités. Par souci de simplicité, je vais choisir les plus courants : les Cherry MX. Ce qui les distingue, c'est la force d'appui, le bruit et le profil qui va recevoir le keycap (en l'occurrence, en forme de X). Pour cette partie, il suffit de les acheter en ligne.

2- le KeyCap

Le keycap est le petit "chapeau" qui se clipse sur le switch. Comme pour les switches, il en existe de toutes sortes. Un ensemble de keycaps pour un clavier est appelé un "keycap set". Ils peuvent être achetés ou fabriqués maison. Attention, il est crucial que le keycap soit compatible avec le switch choisi.

3- l'électronique

C’est la partie la plus complexe. Normalement, le switch est connecté à un circuit qui le fait reconnaître comme un clavier et envoie un signal via USB lorsqu'une touche est activée. Je souhaite reproduire cette logique dans mon contrôleur.

En termes d'électronique, un switch, ou bouton, est très simple, avec deux états : on et off. Si le nombre de touches est inférieur au nombre de GPIO (General Purpose Input/Output) de mon microcontrôleur, c'est très facile à gérer.

Une solution consiste à utiliser un microcontrôleur comme un Arduino (environ 20 euros) pour gérer une entrée via les GPIOs. Cependant, cela peut rapidement devenir coûteux. Il existe de nouvelles alternatives beaucoup moins chères à l’Arduino, comme les ESP8266 (environ 5 euros) ou les Raspberry Pi Pico (entre 6 et 10 euros). J'ai découvert certains clones qui sont devenus populaires, très petits et peu coûteux, tels que le RP2040, un clone du Raspberry Pi Pico disponible sur AliExpress à un prix dérisoire (environ 2 euros pièce). C'est donc la solution que j'ai choisie.

3- le RP2040 et le code

Le microcontrôleur dispose d'une vingtaine de GPIOs, d'un port USB-C pour communiquer avec le PC, et est équipé de la même puce que le Raspberry Pi Pico. Il offre donc les mêmes fonctionnalités que ce dernier.

Il existe une librairie en Python dédiée à la gestion des touches d'un clavier et à la communication avec le PC : KMK Firmware. Cette librairie nécessite l'utilisation de CircuitPython, ce qui est complètement nouveau pour moi.

3.5 Circuit Python et KMK

GitHub - KMKfw/kmk_firmware: Clackety Keyboards Powered by Python
Clackety Keyboards Powered by Python. Contribute to KMKfw/kmk_firmware development by creating an account on GitHub.

Un comportement classique des microcontrôleurs, comme l'Arduino, est de pouvoir les flasher avec du code via un IDE. Le code est compilé (de C++ vers la carte) puis téléversé. Le microcontrôleur devient alors autonome avec le code embarqué et s'exécute dès qu'il reçoit un courant minimum, généralement fourni par le câble USB.

CircuitPython se présente comme :

The easiest way to program microcontrollers

Et je dois admettre que cela change considérablement la donne. La logique devient toute différente.

  1. Il faut télécharger les drivers (au format .uf2) correspondant à votre carte (c'est ainsi que vous pouvez vérifier si votre microcontrôleur est compatible).
  2. Téléversez le fichier sur la carte (comme sur une clé USB). Certaines cartes nécessitent une manipulation pour activer le bootloader UF2. En général, il suffit de double-cliquer sur le bouton reset.
  3. À partir de maintenant, nous pouvons coder directement à l'intérieur de la carte (Getting Started officiel). Pour ma part, je vais importer la librairie KMK et ajouter un exemple de code basique dans code.py.
print("Starting")

import board

from kmk.kmk_keyboard import KMKKeyboard
from kmk.keys import KC
from kmk.scanners import DiodeOrientation

keyboard = KMKKeyboard()

# les pins de la cartes à connecter entre eux
keyboard.col_pins = (board.GP0,) 
keyboard.row_pins = (board.GP1,)

keyboard.keymap = [
    [KC.A,] # la touche envoyé vers le pc
]

if __name__ == '__main__':
    keyboard.go()

Et voilà, ça fonctionne !

Si je connecte deux fils entre la sortie un et deux, la touche A est insérée dans un fichier texte !

En creusant la doc, on peut se rendre compte qu'il y plein de fonction très avancé comme les macros qui vont simuler une suite de touche de clavier ou l'appui de plusieurs touche en même temps !

4- Le Boitier

Pour mes premiers testes,, je souhaite juste insérer mon switch dans une suface pour le tenir. J'ai repris des schema officiel et redessiner en svg de la découpe rapidement que j'ai ensuite envoyé à la découpe laser.

-> lien vers le pdf

Soudé, assemblé, voilà le resultat.

0:00
/0:03

Prochaine étape est de réaliser une boite propre et comprendre comment gérer des touches multiples, puis un layout plus complex !

La bise, Tchouss !

o(*^@^*)o