Table des matières:
Vidéo: Convertisseur de joystick PPM vers USB basé sur Arduino (JETI) pour FSX : 5 étapes
2025 Auteur: John Day | [email protected]. Dernière modifié: 2025-01-13 06:57
J'ai décidé de faire passer mon émetteur JETI DC-16 du mode 2 au mode 1, qui fait basculer essentiellement l'accélérateur et l'ascenseur de gauche à droite et vice versa. Comme je ne voulais pas planter un de mes modèles à cause d'une confusion gauche/droite dans mon cerveau, je me demandais s'il était possible de pratiquer un peu sur FSX.
J'ai lu et testé les émetteurs JETI prenant en charge un mode Joystick prêt à l'emploi, mais je voulais une flexibilité totale pour les affectations d'axes et de commutateurs et utiliser le TX comme avec un vrai modèle. En utilisant la sortie du récepteur, il est également possible d'exploiter le traitement du signal dans le DC-16 et d'utiliser des mélangeurs, des phases de vol, des taux doubles, tout ce que vous pouvez y programmer.
Récemment, j'ai trouvé un bon tutoriel sur la façon de créer un périphérique d'entrée USB HID, à savoir un joystick, à partir d'un Arduino bon marché comme un Pro Micro:
www.instructables.com/id/Create-a-Joystick…
Cela permettrait tout le nécessaire pour contrôler un avion / hélicoptère / quoi que ce soit dans FSX ! Beaucoup d'axes et de boutons disponibles.
Comme je viens d'avoir un JETI RSAT2 de rechange, j'ai décidé de le connecter à l'Arduino et d'essayer d'implémenter un petit analyseur PPM avec la bibliothèque Joystick.
Je suppose que quiconque suit ces étapes est familier avec la connexion et la programmation d'un Arduino. Je ne prendrai aucune garantie pour les dysfonctionnements ou les dommages !
Fournitures
Tu auras besoin de…
- tout Arduino supporté par la librairie Joystick, j'ai utilisé un Sparkfun Pro Micro 5V/16 MHz
- une version récente de l'IDE Arduino
- tout récepteur RC émettant un signal PPM, comme le JETI RSAT2
- quelques cavaliers (min. 3)
- la bibliothèque Joystick installée dans l'IDE Arduino
- la bibliothèque arduino-timer:
Étape 1: câbler le RX et l'Arduino
Le câblage est assez simple. J'ai décidé de n'alimenter l'Arduino qu'à partir de l'USB, car il émulera un périphérique Joystick. Cela alimentera l'Arduino en 5V, qui peut également être utilisé pour alimenter le récepteur RC.
J'ai utilisé la broche VCC, qui fournit une sortie régulée, et la broche Gnd la plus proche - il suffit de la connecter aux broches + et - du connecteur PPM. Lorsque l'Arduino est alimenté, le récepteur s'allume également.
Pour le signal PPM, j'ai décidé d'utiliser des interruptions pour les analyser. Des interruptions sont disponibles, par ex. à la broche 3, il suffit donc de la connecter là-bas - il n'y a pas de "broche RC native" sur l'arduino, mais peut-être plus de façons différentes de lire le signal du récepteur.
J'ai dû désactiver l'alarme de tension RX, car la tension VCC avec alimentation USB sera d'environ 4,5 V seulement - mais assez stable, donc pas de problème du tout.
Étape 2: Obtenir des signaux PPM
Lorsque le récepteur ET le TX sont alimentés, je recevais des signaux PPM comme indiqué sur l'image. 16 canaux, répétés à l'infini. Si Failsafe sur le RSAT est désactivé et l'émetteur éteint, la sortie PPM sera désactivée.
Plus d'informations sur PPM sont disponibles ici:
- https://en.wikipedia.org/wiki/Pulse-position_modul…
- https://wiki.rc-network.de/index.php/PPM
Étant donné que je ne vole pas de vrais trucs dans ce cas, je ne me souciais pas des timings théoriques et je viens de comprendre sur l'oscilloscope ce que mon récepteur émettait réellement en déplaçant les manches de complètement à gauche à complètement à droite (réglages standard dans le TX). Il semblait que -100 % correspond à des impulsions d'une durée de 600 µs et + 100 % à 1600 µs. Je ne me souciais pas non plus de la longueur des impulsions de pause (400 µs) dans mon code Arduino, mais j'ai supposé un espacement de trame de min. 3000µs.
Étape 3: Configuration de l'émetteur
Étant donné que seule la position réelle des gouvernes doit être connue, un canal / "servo" par fonction RC est suffisant. Par conséquent, une configuration d'émetteur assez simple peut être réalisée - similaire à un modèle RC normal. Les fonctions principales aileron, profondeur, gouvernail et manette des gaz ne nécessitent chacune qu'un seul canal d'asservissement respectivement d'émetteur. J'ai également ajouté des volets, des freins et des engrenages, laissant 9 canaux libres jusqu'à présent. Veuillez noter que les volets ont été mis sur une phase de vol, et ne sont pas contrôlés directement via un stick, un curseur ou un bouton.
Étape 4: Exécuter le joystick
La bibliothèque Joystick est assez facile à utiliser et fournit quelques exemples et tests. Il devrait être utile de vérifier d'abord si l'Arduino est détecté comme joystick approprié, les instructions liées dans la section d'entrée et la bibliothèque elle-même fournissent de bons conseils.
Dans le panneau de configuration Périphériques et imprimantes, l'Arduino apparaissait sous le nom de "Sparkfun Pro Micro", et la fenêtre de test du joystick affichait 7 axes et de nombreux boutons pris en charge. Même un interrupteur à chapeau peut être utilisé lorsqu'il est programmé dans l'Arduino.
Étape 5: coder l'Arduino
Ce qui manque encore, c'est l'analyse réelle du signal PPM et l'affectation aux axes et boutons du joystick. J'ai opté pour la cartographie suivante:
Affectation Canal / Fonction / Joystick:
- Accélérateur -> Axe d'accélérateur
- Aileron -> axe X
- Ascenseur -> axe Y
- Gouvernail -> axe de rotation X
- Volets -> axe de rotation Y
- Frein -> axe Z
- Vitesse -> Bouton 0
Lorsque la vitesse est descendue, le premier bouton du Joystick doit être enfoncé et sera relâché lors de la montée de la vitesse. Cependant, cela nécessitera FSUIPC pour FSX, prêt à l'emploi, FSX n'acceptera qu'un bouton pour basculer la vitesse, ce qui n'est pas exactement ce qui se passe avec mes modèles.
J'ai fourni ma version actuelle du code avec beaucoup de commentaires, ce qui fonctionne assez bien pour moi - n'hésitez pas à modifier votre affectation ou à ajouter de nouvelles fonctions. Les 9 derniers canaux RC ne sont actuellement pas utilisés.
Pour la configuration, la classe Joystick doit être initialisée, essentiellement en définissant les plages d'axes numériques:
/* Définir la plage des axes (définie dans l'en-tête, 0 - 1000) */
Joystick.setXAxisRange(CHANNEL_MIN, CHANNEL_MAX); Joystick.setYAxisRange(CHANNEL_MIN, CHANNEL_MAX); …
En utilisant des valeurs de 0 à 1000, il est possible de mapper directement la longueur d'impulsion (600 - 1600 µs) aux valeurs du joystick sans redimensionnement.
Le DIN 3 est initialisé en tant qu'entrée numérique, les pullups sont activés et une interruption est attachée:
pinMode(PPM_PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(PPM_PIN), PPM_Pin_Changed, CHANGE);
À des fins de débogage, j'ai ajouté des impressions via l'interface série à intervalles réguliers, en utilisant la bibliothèque arduino-timer:
if(SERIAL_PRINT_INTERVAL > 0) {
scheduler.every(SERIAL_PRINT_INTERVAL, (void*) -> bool { SerialPrintChannels(); return true; }); }
L'interruption de la broche sera appelée chaque fois que la valeur logique de la broche a changé, donc pour chaque front du signal PPM. Évaluez la longueur d'impulsion simplement par une simple synchronisation à l'aide de micros ():
uint32_t curTime = micros();
uint32_t pulseLength = curTime - edgeTime; uint8_t curState = digitalRead(PPM_PIN);
En évaluant l'état de la broche actuelle et en le combinant avec la longueur d'impulsion et les impulsions passées, les nouvelles impulsions peuvent être classées. Le conditionnel suivant détectera l'écart entre les trames:
if(lastState == 0 && pulseLength > 3000 && pulseLength < 6000)
Pour les impulsions suivantes, la longueur d'impulsion sera mappée sur un état d'axe en écrêtant et en polarisant la longueur d'impulsion pour correspondre à la plage de l'axe du joystick:
uint16_t rxLength = pulseLength;
rxLength = (rxLength > 1600) ? 1600: rxLength; rxLength = (rxLength < 600) ? 600: rxLength; rxChannels[curChannel] = rxLength - 600;
Le tableau rxChannels contient finalement 16 valeurs de 0 à 1000, indiquant les positions du stick / curseur et des boutons.
Après avoir reçu 16 canaux, le mappage vers le Joystick est effectué:
/* axes */
Joystick.setThrottle(canaux[0]); Joystick.setXAxis(canaux[1]); Joystick.setYAxis(1000 - canaux[2]); Joystick.setRxAxis(canaux[3]); Joystick.setRyAxis(canaux[4]); Joystick.setZAxis(1000 - canaux[5]); /* boutons */ Joystick.setButton(0, (canaux[6] < 500 ? 1: 0)); /* mettre à jour les données via USB */ Joystick.sendState();
J'ai inversé certains axes dans le code, ce qui n'est pas absolument nécessaire, car l'axe peut également être inversé en inversant la direction du servo ou l'affectation dans FSX. Cependant, j'ai décidé de conserver les directions des servos ainsi que l'affectation FSX d'origine.
Le bouton est activé ou désactivé par seuillage du canal 7.
Et n'oubliez pas de cocher le planificateur…sinon, aucune impression de débogage ne sera visible.
boucle vide() {
planificateur.tick(); }
Dans la capture d'écran que j'ai jointe, vous pouvez voir que le canal 1 a été déplacé de 1000 (plein régime) à 0 (inactif).
FSX détectera l'Arduino comme n'importe quel autre joystick, alors assignez simplement le bouton et les axes et amusez-vous à décoller !
Ce que j'aime vraiment dans cette approche, c'est que vous pouvez simplement utiliser votre émetteur comme avec un vrai modèle, par ex. en utilisant les phases de vol, etc.