image de mise en avant pour l'article Button box arduino pour simracing

Création d’une Button Box Simracing avec des cartes Arduino

Temps de lecture estimé: 20 minutes

Récemment je me suis rendu compte que si je vais toujours dans le bac à sable et que je finis dernier, c’est parce que je ne peux pas régler correctement ma fusée et qu’il me fallait du matos en plus …  absolument faux!!! Je voulais juste compléter mon attirail de simracing et bidouiller un peu d’électronique.

J’ai déjà fait un tableau de bord / Dashboard Simracing avec un Raspberry Pi et quand je me renseignais sur les accessoires simracing qui pouvaient rendre l’expérience plus immersive, je suis tombé sur la Button Box, littéralement une boite à bouton. Ce qui permet de définir des touches et de changer les réglages de la voiture d’une façon un peu plus réaliste / immersive qu’un simple clavier.

Il y en a des toutes faites par des accessoiristes PC ou par des constructeurs un peu plus artisanaux. Mais d’une part , ce n’est pas donné et pour le fun je me suis dit que je pouvais la faire moi-même…

Je te propose donc dans cet article la conception d’une button box à l’aide d’un Arduino

  1. Le matériel
  2. Un Arduino c’est quoi ?
  3. Les bases de l’Arduino
  4. Le bouton-poussoir
  5. Le bouton poussoir NC
  6. L’interrupteur à bascule
  7. L’interrupteur 3 positions
  8. L’encodeur rotatif (avec bouton-poussoir)
  9. Le joystick analogique de manette
  10. Les grilles
  11. Le dernier contretemps
  12. Le code final
  13. Le boitier

À la base, je suis tombé sur ce genre de tuto:

Avec le code dispo sur https://github.com/AM-STUDIO/32-FUNCTION-BUTTON-BOX

Ça s’annonçait plutôt simple. « Juste à » télécharger le code source, à suivre le plan et à souder et faire le câblage comme indiqué…

Le matériel

Ni une ni deux , je commande tout le nécessaire, le microcontrôleur conseillé dans la vidéo et les boutons que moi je voulais mettre:

(Je ne suis pas un expert en électronique, mais en sachant que l’Arduino délivre du 5V, l’idéal, je pense, est d’avoir des boutons en adéquations, mais saches que certains des boutons que j’ai commandés  sont des 12v, mais fonctionnent parfaitement)

Bien sûr , tu peux trouver tout ça sur Amazon, mais aussi sur d’autres plateformes de ton choix et surtout dans une boutique d’électronique près de chez toi si tu en as une.

Et sinon au niveau outils, je n’avais rien coté électronique et il me fallait au minimum:

Et pour tester plus facilement j’ai aussi pris et pour me faire un stock électronique et éventuellement bidouiller d’autre truc avec un Arduino

Voilà j’ai reçu tout ça il y a quelque temps déjà, mais je m’y suis attelé récemment.
Spoiler alert!! Rien ne s’est passé comme prévu!!

Alors, commençons par le commencement:

un Arduino c’est quoi?

un Arduino c'est quoi ?
un Arduino c’est quoi ?

Un Arduino est un circuit imprimé qui permet de bidouiller des petits trucs (et des plus gros trucs) électroniques bien sympas. Ça permet de gérer des entrées et sorties digitales analogiques et digitales assez facilement sans être un grand expert (il faut juste avoir quelques notions en électronique et en programmation) et le tout a un prix plutôt abordable.

En gros avec 3 / 4 lignes de codes, on peut allumer une LED (sortie) lorsque quelqu’un appuie sur un bouton (entrée).

c’est assez basique comme exemple, mais on peut monter en puissance et on pourrait imaginer une lampe d’intérieur qui s’allumerait automatiquement lorsque la luminosité de la pièce est trop faible

Ou

mesurer la température de la pièce et l’afficher sur un écran LCD tout en déclenchant le chauffage si elle descend en dessous d’un certain seuil.

Ou

descendre ou remonter un store manuel à partir de son smartphone, un Arduino avec un module wifi et un moteur électrique

Bref il y a plein d’application possible et je te laisse aller voir sur un moteur de recherche si tu es curieux

Dernier point, « un Arduino » est un abus de langage puisqu’à la base Arduino est une THE marque qui fournit les circuits imprimés. Les plans de ces circuits imprimés sont libres de droits, tout le monde peut les reproduire. C’est pour ça qu’il y a plein de marques alternatives chinoises 3 fois moins chères que les cartes « originales » de la marque Arduino. Donc par extension Arduino est une marque qui est devenue aussi l’objet (comme a marque Scotch qui est couramment utilisé pour désigner du ruban adhésif par exemple).

Les bases d’Arduino

Donc me voilà parti pour réaliser la button box avec la vidéo et le code fourni.

À la première ouverture du code, je n’ai absolument rien compris au but de ce programme et je n’avais pas trop d’idée de comment il était censé fonctionner. Comment il prenait en compte les entrées des boutons et comment il envoyait le signal à l’ordinateur. D’autant plus que le code n’est pas commenté et les noms ne sont pas spécialement explicites au premier abord (mais ça j’y reviens plus tard).

Donc quitte à le faire moi-même, autant comprendre un peu ce qu’il y a sous le capot et ne pas copier bêtement.

C’est mon premier projet Arduino. L’informatique et le développement / la programmation, ça va je maitrise… Par contre l’électronique c’est pas trop ça… J’ai dû faire appel au reste de mes cours d’électronique qui remonte maintenant au lycée…

Au delà de l’électronique, il y a cette carte mystérieuse avec tous ses sigles étranges A0, 1, 2, GND, TX, RX, RST …

Après quelques recherches, j’ai trouvé quelques sites (en plus du site officiel Arduino https://www.arduino.cc/ ) qui récapitulent et démystifient un peu les bases de cette petite bébête.

notamment
https://zestedesavoir.com/tutoriels/686/arduino-premiers-pas-en-informatique-embarquee/
et
http://www.lycee-ferry-versailles.fr/ee-tsi/12_arduino/html/p2.html

Bon on comprend vite qu’il n’y a pas grand-chose de sorcier:

  • Entrée Ax (a0, a1 etc) => analogique
  • Entrées/sorties numériques D0 à D13
  • Masse GnD (ground / terre)
  • TX, RX entrée et sortie « série » pour traiter des signaux un peu plus compliqués que de l’analogique et du digital
  • RST reset , ça fait sens quand on le sait…

Au-delà de l’électronique, il y a un point important à comprendre. l’Arduino va exécuter ton code en boucle.

Quand il aura fini, il recommencera.. Encore .. Et encore… mais ça à une vitesse folle. Donc avec un exemple simple d’un bouton poussoir, l’Arduino va vérifier 100 millions de fois par seconde si le bouton est appuyé (chiffre pas exact, mais l’idée est là). Donc quand toi tu vas appuyer une fois sur ton bouton (et rester appuyer plus ou moins longtemps), en fait l’Arduino aura compris 1000 fois que tu appuies sur le bouton.

Pour le code, tu vas avoir besoin du logiciel Arduino IDE.
C’est dans ce logiciel que tu vas pouvoir écrire ton code arduino, le compiler et l’envoyer sur le circuit imprimé. Il y a aussi plein d’exemples simples livrés avec.

Un code de base comprend au minimum 2 fonctions.

La fonction setup

void setup() {

}

c’est une fonction qui va être exécutée une seule fois. c’est dans celle-ci qu’on va initialiser quelques valeurs, prendre les états de base

La fonction loop

void loop() {

}

Elle va tourner, comme son nom l’indique, en boucle. Elle se répète à l’infini.

Si on reprend l’exemple du bouton, c’est dans cette fonction qu’on va vérifier en boucle
« est-ce que le bouton est appuyé? Si Oui alors… / Si Non alors… »
« est-ce que le bouton est appuyé? Si Oui alors… / Si Non alors… »
« est-ce que le bouton est appuyé? Si Oui alors… / Si Non alors… »

Les bases en main, je voulais attaquer par des trucs simples et monter progressivement en puissance. Pour ça je me suis dit, je dois comprendre le fonctionnement et coder chaque bouton séparément.

Le bouton poussoir

C’est avec le simple bouton poussoir que j’ai mis en place et compris 90% de ce dont j’avais besoin pour faire la button box.

cette partie est un peu longue et ferait très bien un article d’initiation à l’Arduino au travers de la mise en place d’un bouton poussoir

On commence simplement. D’abord on va venir physiquement connecter son bouton à une broche / un « pin »  d’entrée digitale. Disons le pin 2.

Il va donc falloir indiquer au programme que le pin 2 est une entrée (INPUT). On ne va pas l’indiqué à chaque passage dans la boucle, mais une seule fois dans la fonction d’initialisation setup()

void setup() {
  pinMode(2, INPUT);
}

Pour mieux se repérer par la suite et éviter d’utiliser juste des numéros de broche, on va déclarer une variable avec un nom explicite

const int Button = 2;

void setup() {
  pinMode(Button, INPUT);
}

Et voilà, on a plus qu’à lire la valeur de l’entrée digitale (1 ou 0) à chaque passage dans la boucle et à en faire ce qu’on veut

const int Button = 2;

void setup() {
  pinMode(Button, INPUT);
}

void loop() {
  int ButtonVal = digitalRead(Button);
}

La première leçon apprise avec un simple bouton poussoir, c’est qu’il y a plein de parasitage et de perturbations avec l’électronique. J’ai passé quelques heures à tester avec ce premier code, à essayer d’allumer la LED interne et ne pas comprendre pourquoi mon bouton ne fonctionnait pas (comme je voulais en tout cas) et que la LED ne s’allumait pas quand j’appuyais dessus, mais elle clignotait aléatoirement.

J’ai compris au bout d’un moment que j’arrivai à allumer la LED (et à « appuyer » sur le bouton) juste en rapprochant mon doigt du câble.

Ça parait simple pour nous de ce dire que c’est soit « On » , soit « Off ». Mais en réalité le signal électrique oscille entre 0v  (etat theorique « Off ») et 5v (état théorique « On ») et cet état peut être parasité par … un doigt par exemple dans mon cas…  Pour contrer ces effets là, il est courant en pratique d’installer des résistances, c’est ce qui s’appelle une résistance pullup .

Donc au lieu de considérer le 5v comme « on » et le 0v comme « off » , on fait l’inverse.

https://zestedesavoir.com/media/galleries/954/32c84ea3-a6b3-47ba-bac4-bae6abdc1d74.png.960x960_q85.jpg

On branche le bouton au 5v avec une résistance à une entrée de l’arduino. Donc par défaut le bouton va être considéré par l’arduino comme « on » . Et lorsqu’on va appuyer sur le bouton, ça va créer un contact avec la terre / le ground . Le signal va donc tomber à 0v (puisqu’il y a une résistance sur le « chemin » 5v et que c’est plus facile pour le signal de passer par le ground)

l’avantage c’est d’avoir un signal clair
5v (ou parasite) => état normal
0v => état appuyé

Il ne faut pas oublier dans le code de considérer l’état inverse
Si HIGH => bouton non appuyé
Si LOW => bouton non appuyé

Voilà pour le principe général. Dans la pratique l’Arduino permet d’avoir un pullup interne, directement intégré à la carte. Ça évite d’avoir à utiliser sa propre résistance pour chaque bouton.

Pour ça il suffit juste de déclarer la broche digitale non pas comme une entrée (INPUT), mais une entrée Pullup (INPUT_PULLUP)

pinMode(Button, INPUT_PULLUP);

Éventuellement, si on souhaite faire du debug et suivre un peu ce qu’il se passe, on peut utiliser la console série et y « imprimer » quelque chose avec

Serial.println("j'affiche un message");

Et bien, dis donc!!! Les principes avancent pour ce premier bouton!!! Pour le prochain point, je reviens à ce que je disais plus haut. L’Arduino va exécuter la boucle des 100aines de milliers de fois à la seconde. Donc si tu restes appuyer sur le bouton, toi tu considères que tu as appuyé 1 fois et que tu maintiens le bouton. Mais pour l’Arduino, lui, va se dire à chaque fois:

Est-ce que le bouton est appuyé? Oui il est appuyé alors je fais une nouvelle fois l’action « bouton appuyé ».

Quelque chose d’assez courant est donc de connaitre l’état du bouton à la boucle d’avant. Ça va permettre de comparer et d’agir en conséquence en fonction de son besoin.
Et donc pour mon besoin, je considère que

  • si le statut est le même que celui d’avant, le statut HIGH, c’est que le bouton est resté relâché (on se souvient HIGH => relâché parce que c’est inversé avec le Pullup)
  • si le statut est le même que celui d’avant, le statut LOW, c’est que le bouton est resté appuyé.
  • Si le statut n’est pas le même que celui d’avant, s’il passe de HIGH à LOW, c’est que l’utilisateur vient d’appuyer sur le bouton.
  • Si le statut n’est pas le même que celui d’avant, s’il passe de LOW à HIGH, c’est que l’utilisateur vient de relâcher  le bouton.

Et bien voilà c’est plutôt pas mal. Maintenant qu’on à tous nos cas, il ne reste plus qu’à décider quoi faire…

En général, pour tester/débuter, on essaie d’allumer la LED interne ou une LED branchée sur une sortie digitale. Admettons qu’on branche une LED sur la broche 9 (+ sur la 9 et – sur le ground), il faudrait déclarer dans l’initialisation que la broche 9 sera, une sortie

pinMode(9 , OUTPUT);  

Et ensuite quand on voudra allumer la LED, dans la boucle quand l’utilisateur appuie sur un bouton, par exemple, il suffit d’écrire le statut haut (1 / 5v) sur la sortie digitale 9

digitalWrite(9, HIGH);

Et pour l’éteindre

digitalWrite(9 , LOW);

Dans mon cas, je ne veux pas allumer une LED, mais envoyer un signal à l’ordi sur lequel l’Arduino sera brancher et lui dire

Coucou je suis un Arduino « manette » et quand quelqu’un appui sur le bouton, je t’envoie le message « bouton de manette 1 appuyé »)

Pour ça il faut que l’Arduino soit considéré par l’ordinateur comme un HID (human interface device) , un périphérique d’interface humaine, comme un clavier ou une souris ou… une manette !!

Arduino et les contributeurs ont tout prévu et pour ça on va utiliser une librairie HID-Project.

Pour installer une librairie, c’est ici. Donc on inclut la librairie au début de son code

#include "HID-Project.h"

On initialise la manette dans la fonction setup

Gamepad.begin();

puis dans le cas d’un bouton, on va indiquer qu’une touche (la 1 par exemple) est pressée

 Gamepad.press(1);

l’état de la manette est stocké dans une espèce de buffer. Pour faire passer l’info à l’ordi, on n’oublie pas

Gamepad.write();

Et bien voilà , j’ai fini avec les bases pour faire fonctionner un bouton simple sur un Arduino. J’ai aussi un peu réorganisé le code et prévu un peu la suite. mon code pour le bouton est disponible sur mon gitlab

Vraiment , une fois que le simple bouton poussoir est fait et fonctionnel, le plus gros est fait. C’est ensuite de l’adaptation à d’autres types de boutons et de l’optimisation.

Le bouton poussoir NC

Pour faire comme dans une vraie voiture de course / sport , le gros bouton de démarrage « start engine » … vroooomm!!

J’ai donc pris ce bouton sans vraiment comprendre ce que c’était le « NC » c’est quand je l’ai branché et testé avec le même code du bouton que j’ai cherché et compris que NC, c’est juste Naturaly Closed. Ça veut dire que dans l’état normal du bouton, le circuit est fermé. par défaut, le bouton est « On », il faut donc appuyer sur le bouton pour couper le contact, pour être « off » .

Une fois ça en tête, le code pour ce bouton est quasiment le même que le bouton poussoir. C’est juste que l’état est inversé (on se rappelle aussi qu’il y a une première inversion avec le INPUT_PULLUP).

Et Pamm!! Un autre type de bouton de géré!!

le code est dispo sur le gitlab

L’interrupteur à bascule

interrupteur à bascule
interrupteur à bascule

Étonnement , c’est sur celui-ci que j’ai passé le plus de temps. C’est un simple interrupteur à bascule avec une LED.

Il a 3 broches, le + , la terre et la LED . Je pensais donc qu’il fallait gérer manuellement un output pour la LED .

Quand le bouton est en position « on » alors on envoie un signal « on » sur la broche de l’arduino branché à la LED.

Sauf que j’avais plein de signaux parasites. J’ai cherché longtemps. J’ai essayé plusieurs façons de le câbler. J’ai essayé avec le pullup interne à l’Arduino. J’ai essayé sans. J’ai utilisé une résistance externe. J’ai essayé de debounce le signal avec du code, avec un condensateur, etc etc…

Pour finalement m’apercevoir que la LED se gérait automatiquement et que je n’avais pas besoin de gérer moi-même la sortie vers la LED et que du coup le branchement n’était pas bon…

En branchant bien , ça fonctionne mieux.

Pour le code, la logique est différente du bouton puisque là où on peut maintenir le bouton pressé, l’interrupteur à bascule n’est pas maintenu. Il a juste changé d’état, de « off » à « on » ou de « on » à « off ». Donc, dans mon cas , je ne cherche pas à avoir un statut qui reste « appuyé » sur le bouton de la manette si l’interrupteur reste en « on » et à relâcher le bouton de la manette quand l’interrupteur va en « off » mais bien à détecter un changement de statut et envoyer un signal manette à chaque changement d’état.

le code est dispo sur le gitlab

L’interrupteur 3 positions

interrupteur 3 positions
interrupteur 3 positions

Là encore, c’est sur le branchement que j’ai passé le plus de temps, mais une fois le principe saisi, ça passe tout seul.

c’est un interrupteur 3 positions donc une position neutre, une position droite et une position gauche. Pour chaque position il y a 3 broches (et 2 choix), un neutre, une broche NC et son contraire, une broche NO (Naturally Open, donc ouverte par défaut). Il y a aussi le + et le – pour alimenter la lumière de ce bouton.

Pour le code, on est plus proche du bouton poussoir, sauf que là il y en a 2…

le code est dispo sur le gitlab

Le codeur rotatif (avec bouton poussoir)

le codeur rotatif que j’ai choisi à un bouton sur le top. Il y a 2 donc partie, une partie concerne le bouton donc là cf. bouton poussoir.

Et la partie codeur rotatif. Celle-ci fonctionne avec 2 inputs distincts, disons A et B.
Chaque input alterne entre LOW et HIGH dans un ordre qui dépend du sens.
ça nous offre donc 8 combinaisons possibles, 2 états finaux et 2 états de transitions dans chacun des sens.

Donc, avec cette logique et en se basant sur A comme mesure principale (ça revient au même en se basant sur B, il faut juste inverser) , on aurait
Dans le sens horaire:

A=0 B=1 => état de transition
A=0 B=0 => état final
A=1 B=0 => état de transition
A=1 B=1 => état final

Dans le sens antihoraire:

A=0 B=0 => état de transition
A=0 B=1 => état final
A=1 B=1 => état de transition
A=1 B=0 => état final
https://howtomechatronics.com/wp-content/uploads/2016/07/Rotary-Encoder-Output-Signal-Working-Principle-Photo-.png

Maintenant pour savoir si ça tourne il suffit de vérifier si l’état actuel de A est différent du précédent?

S’il est différent, c’est qu’on est en mouvement.
s’il n’est pas différent, c’est

  1. Soit qu’on est resté en état final (pas de mouvement),
  2. soit qu’on passe de l’état de transition à l’état final, et ça, ça ne nous apporte rien, on s’en moque….

Très bien ! Mais dans quel sens maintenant?

Pour ça on compare l’état actuel (et comme dit au dessus l’état actuel est l’état de transition) de A à l’état actuel de B, s’ils sont différents, c’est dans le sens horaire. Si A et B sont dans le même état , c’est le sens antihoraire.

Dans mon cas, mes rotary encoder ont 2 étapes à chaque cran. C’est-à-dire que pour une rotation, je change 2 fois d’états. Pour la conception de ma button box, ça ne m’intéresse pas d’envoyer 2 fois le signal à l’ordinateur pour la manette. Je compte donc les rotations et je n’envoie le signal que lorsque le compteur est pair (l’opérateur modulo =>  counter % 2 == 0 ).

Et comme je ne veux pas rester « appuyer » sur le bouton, je presse le bouton succinctement, j’attends 300ms et je relâche le bouton.

le code est dispo sur le gitlab

Le joystick analogique de manette

Joystick analogique branché à l'Arduino
Joystick analogique branché à l’Arduino

Et il nous reste le dernier type d’entrée, celui que je pensais être le plus compliqué et qui en fait c’est plutot bien passé: le joystick analogique. Tout comme le rotary encoder, le joystick possède un bouton , pour ça encore une fois c’est facile, cf bouton pressoir.

Sinon pour le joystick, après l’avoir connecté comme il faut , le 5v sur le 5v , le ground sur le ground

Le bouton sur une entrée digitale et les 2 axes x et y sur des entrées analogiques , place au code

Déjà, on ne lit plus de valeurs digitales, mais analogiques, donc on utilise analogRead pour lire les valeurs

Ensuite La Librairie HID-Project.h a déjà une fonction qui gère les joysticks. Assez simple, on fournit une valeur pour X, une valeur pour Y , le tout en 16 bits et le tour est joué…

Euuuhh oui…

Alors déjà sur 16bit, ça fait 65535 valeurs possibles, est-ce que le centre c’est 32767, est-ce que c’est 0?!

Ce n’est pas vraiment indiqué dans la doc et dans l’exemple , c’est des valeurs aléatoires…

OK donc en testant avec des valeurs en dur, je me suis aperçu que le centre est 0, à partir de là, j’en ai déduit que le max c’est 32766 et le minimum est négatif et c’est -32765.

Très bien, mais mon joystick lui son centre pour x c’est 517 et pour y c’est 531. Et que les 2 vont de 0 à 1023

Comment qu’on fait?!!

Et bien simplement, on fait l’équivalence. Et ça tombe plutôt bien puisqu’il y a une fonction pour ça: map

On a ensuite juste à envoyer les valeurs à la fonction

Gamepad.xAxis(xMap);  
Gamepad.yAxis(yMap);
Gamepad.write();

le code est dispo sur le gitlab

Les grilles

Maintenant que j’ai vu tout ça, le fichier du début me parle un peu plus. Il me restait cependant un dernier mystère à élucider: les grilles.

Là, c’était gentil avec mes tests sur chaque type de boutons, j’ai eu le luxe d’avoir une entrée dédiée pour chaque bouton. Mais comment diable le branchement qu’il a fait dans sa vidéo peut fonctionner, comment récupérer l’état des boutons proprement sans que tout se parasite…

Et bien assez simplement en fait. En comprennant finalement que la vérification, c’est-à-dire le code de la boucle est exécuté X milliers de fois à la seconde et que par conséquent on peut « s’amuser » à vérifier l’état d’un bouton d’après sa colonne et sa ligne.

j’ai trouvé ça très bien expliqué ici https://www.teachmemicro.com/arduino-keypad-interfacing-4×4-matrix/

l’avantage aussi c’est que ça permet de faire un mappage de la grille assez facilement avec le keypad.

J’ai testé les grilles, j’ai compris, mais malheureusement…  je ne m’en suis pas servie. c’est à cette étape que j’ai compris que, dans l’état, ça n’allait pas le faire…

Le dernier contretemps…

j’avais juste un petit doute qui s’est confirmé après avoir réfléchi un peu 2 secondes, j’ai fait un listing et un plan (avec fritzing)

Schema de ma grille Arduino
Schema de ma grille Arduino

j’ai fait l’inventaire:

  • 10 boutons poussoir simple => 10 entrées digitales, possible en grille
  • 5 boutons pour les codeurs rotatifs => 5 entrées digitales, possible en grille
  • 1 bouton pour le joystick analogique => 1 entrée digitale, possible en grille
  • 1 gros bouton NC =>  1 entrée digitale, possible en grille
  • 3 boutons 3 positions (une position neutre au milieu et 2 positions gauche / droite) => 6 entrées digitales, possible en grille.
  • 5 interrupteurs à bascule => 5 entrées digitales, possible en grille
  • 5 codeurs rotatifs => 10 entrées digitales dédiés   
  • 1 joystick analogique => 2 entrées analogiques dédiées

Ce qui me donne:

  • 11 entrées digitales pour la grille (28 entrées digitales  => 6×5 = 30 donc 6 entrées en ligne et 5 entrées en colonnes)
  • 10 entrées digitales dédiées
  • 2 entrées analogiques

Je suis à 23, là où un Arduino micro pro permet 18 entrées possibles (si on compte les entrées analogiques qui peuvent être utilisées en digitales et les entrée/sortie série qui peuvent aussi être utilisées en entrées digitales

Et c’est à ce moment-là que j’ai compris que même avec une grille, je n’aurais pas assez d’entrées pour connecter tout ce que j’avais prévu.

J’avais donc 3 choix:

  • Renoncer à quelques boutons et le stick analogique. Moi renoncer?! Jamais!!!!
  • Soit faire le câblage sur 2 Arduino pro mini. Et donc brancher 2 câbles USB au PC ensuite (brancher 2 manettes en fait..). Pourquoi pas, mais..
  • La 3e solution est d’acheter une autre carte, un peu plus grosse, un peu plus cher (mais pas non plus foufou), mais qui me permettra de faire tous les branchements souhaités… et sans même à me casser la tête avec une grille 

c’est donc ce que j’ai fait en commandant la carte Arduino Due

Le code final

Bien sûr cette partie n’est pas exempte de galère…
Déjà, l’Arduino Due n’était pas compatible avec la librairie de joystick que j’utilisais. Après avoir réadapté ça avec une autre librairie (https://github.com/MHeironimus/ArduinoJoystickLibrary), j’ai testé avec mon jeu (Project Cars 2). Je ne sais pas vraiment pourquoi, mais ça ne fonctionnait pas comme souhaité. Je pense problème entre le volant, considéré comme une manette, et la button box, elle aussi considéré comme une manette (2 manettes pour un seul joueur…).

Mais à vrai dire je n’ai pas vraiment cherché plus loin et j’ai au final switché le fonctionnement comme un « simple » clavier. J’ai aussi changé quelques lignes et apporté quelques étapes de vérifications par rapport aux exemples ci-dessus.

Tu peux aller voir tout ça sur mon gitlab. le code final de Ma button box que j’ai mis en place avec mes contraintes est disponible ici.

j’ai également repris le code de AM studio que je ne comprenais pas au début et que je me suis permis de commenter pour plus de clarté (pour moi en tout cas). Il est dispo ici.

Le boitier

Et la touche finale, la mise en place de tout ça dans le boitier…
De ce côté, pas de problème particulier… quand on a les bons outils.

J’ai juste essayé de placer les boutons harmonieusement sur le couvercle du boitier. Je les ai d’abord positionnés grossièrement dessus pour voir différents agencements possibles

disposition des boutons sur le boitier
disposition des boutons sur le boitier

Puis une fois décidé, j’ai tracé une grille, mesurer les espaces entre les éléments et là où je devais percer.

grille sur le boitier
grille sur le boitier

Une fois le pré perçage fait, place à la peinture pour avoir un boitier noir.
Je dis pré perçage puisqu’évidement je n’avais pas les forets de bon diamètre. d’ailleurs, j’ai pris des forets étagés multi diamètres assez efficaces.
Et on n’oublie pas non plus le trou sur le fond pour laisser passer le câble USB qui ira de l’Arduino jusqu’au PC et éventuellement des trous de fixation de la boite sur ton éventuel support volant.

Boitier peint
Boitier peint

Pour le côté racing, j’ai collé du vrai adhésif de faux carbone

Du vrai faux carbone
Du vrai faux carbone

Ça, c’était le plus facile. Maintenant, la soudure!!!

Le circuit imprimé (l’Arduino Due) possède 3 broches ground / terre / GND. Impossible donc de brancher chaque bouton sur une fiche terre différente. Non, il faut souder en série toutes les terres pour n’avoir au final que 1, 2 ou 3 broches terres. Dans mon cas j’ai utilisé les 3. Tous les interrupteurs et boutons sont soudés en série pour ne donner qu’une fiche Dupont pour la terre. Les codeurs rotatifs sont eux aussi en série pour n’avoir qu’une seule terre. Le joystick lui a le droit à son GND dédié.

J’ai fait de même avec le 5 volts. J’ai soudé en série ce qui en avait besoin (les 5 interrupteurs à LED et les 3 interrupteurs 3 positions).

Le reste est soudé indépendamment avec du fil et un connecteur Dupont mâle à chaque extrémité pour pouvoir le brancher sur des entrées distinctes de l’arduino. Si tu peux éviter de faire comme moi et si tu peux prévoir une longueur suffisante pour pas que les câbles ne soient pas tendus, c’est mieux.

ça donne quelque chose comme

câblage plus ou moins ordonné
câblage plus ou moins ordonné

Avant de refermer le boitier, je te conseille de le brancher et de retester tous les boutons pour voir s’il n’y a pas une rectification de soudure ou un branchement à l’Arduino à refaire.

Et voilà, plus d’excuse maintenant!!

Tu n’as plus qu’à configurer les boutons avec ton jeu, éventuellement de mettre quelques étiquettes pour te rappeler des fonctions et c’est parti !!!

le boitier mis en place
le boitier mis en place


Ou p’tetre qu’il me manque le simulateur 4dof?! Mais ça, ce n’est pas pour tout de suite alors en attendant, je n’ai plus qu’à faire descendre les chronos….

Dis-moi si tu t’en es servi pour faire toi aussi ta propre Button box (ou autre projet Arduino).
N’hésite pas si jamais tu as besoin d’un coup de main sur cette mise en place.

En attendant, je te dis à très bientôt dans de nouvelles aventures !!

Partagez l'article:
FacebookTwitterEmailLinkedIn

3 réflexions au sujet de « Création d’une Button Box Simracing avec des cartes Arduino »

  1. Bonjour,
    Alors la, je dis bravo pour ces explications.
    J’hésite depuis pas mal de temps entre acheter une boite toute faite, qui ne me convient pas forcément (et chère) et m’y coller moi-même tout seul comme un grand. Seulement le hic, c’est de trouver le bon tuto qui réponde à plusieurs de mes questions (surtout concernant la programmation Arduino) Tu as comblé mon désir (En tout bien tout honneur bien sur)
    Y a pu qu’a …
    Merci pour ce boulot
    Très amicalement
    Philippe
    PS : Il y a une petite erreur : La lecture m’a pris 1h30 😉

    1. Bonjour Philippe!
      Je suis vraiment content que ça puisse servir!
      J’avoue que le temps de lecture estimé (généré automatiquement) est peut-être un peu optimiste…
      Y a pu qu’a … je suis curieux de voir le résultat si tu as terminé la box!

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.