Convertitore Joystick da PPM a USB basato su Arduino (JETI) per FSX: 5 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Ho deciso di cambiare il mio trasmettitore JETI DC-16 dalla modalità 2 alla modalità 1, che sostanzialmente commuta Throttle e Elevator da sinistra a destra e viceversa. Dato che non volevo mandare in crash uno dei miei modelli a causa di un po' di confusione sinistra/destra nel mio cervello, mi chiedevo se fosse possibile esercitarsi un po' in FSX.

Ho letto e testato i trasmettitori JETI in realtà supportano una modalità Joystick fuori dalla scatola, tuttavia volevo la massima flessibilità per le assegnazioni degli assi e degli interruttori e utilizzare il TX come con un modello reale. Utilizzando l'uscita del ricevitore, è anche possibile sfruttare l'elaborazione del segnale nel DC-16 e utilizzare mixer, fasi di volo, dual rate, qualunque cosa tu possa programmare lì.

Recentemente ho trovato un bel tutorial su come realizzare un dispositivo di input USB HID, ovvero un Joystick, da un Arduino economico come un Pro Micro:

www.instructables.com/id/Create-a-Joystick…

Ciò consentirebbe tutto il necessario per controllare un aereo / elicottero / qualunque cosa in FSX! Un sacco di assi e pulsanti disponibili.

Dato che avevo appena un JETI RSAT2 di riserva, ho deciso di collegarlo con Arduino e provare a implementare un piccolo parser PPM insieme alla libreria Joystick.

Suppongo che chiunque segua questi passaggi abbia familiarità con la connessione e la programmazione di un Arduino. Non mi assumo alcuna garanzia per malfunzionamenti o danni!

Forniture

Avrai bisogno…

• qualsiasi Arduino supportato dalla libreria Joystick, ho usato uno Sparkfun Pro Micro 5V / 16 MHz
• una versione recente dell'IDE Arduino
• qualsiasi ricevitore RC che emette un segnale PPM, come JETI RSAT2
• alcuni ponticelli (min. 3)
• la libreria Joystick installata nell'IDE Arduino
• la libreria arduino-timer:

Passaggio 1: collegare l'RX e l'Arduino

Il cablaggio è abbastanza semplice. Ho deciso di alimentare Arduino solo da USB, poiché emula un dispositivo Joystick. Ciò fornirà all'Arduino 5V, che possono essere utilizzati anche per alimentare il ricevitore RC.

Ho usato il Pin VCC, che fornisce un'uscita regolata, e il pin Gnd più vicino - basta collegarlo ai pin + e - del connettore del PPM. Quando Arduino viene alimentato, anche il ricevitore si sta accendendo.

Per il segnale PPM, ho deciso di utilizzare gli interrupt per analizzarli. Gli interrupt sono disponibili ad es. al Pin 3, quindi collegalo lì - non c'è un "pin RC nativo" sull'arduino, ma forse più e diversi modi per leggere il segnale del ricevitore.

Ho dovuto disabilitare l'allarme di tensione RX, poiché la tensione VCC con alimentazione USB sarà solo di circa 4,5 V, ma abbastanza stabile, quindi nessun problema.

Passaggio 2: ottenere alcuni segnali PPM

Quando il ricevitore E il TX sono alimentati, ricevevo segnali PPM come mostrato nell'immagine. 16 canali, ripetuti all'infinito. Se Failsafe sull'RSAT è disabilitato e il trasmettitore spento, l'uscita PPM sarà disabilitata.

Maggiori informazioni su PPM sono disponibili qui:

• https://en.wikipedia.org/wiki/Pulse-position_modul…
• https://wiki.rc-network.de/index.php/PPM

Dato che non sto pilotando cose reali in questo caso, non mi sono preoccupato dei tempi teorici e ho solo capito sull'oscilloscopio cosa stava effettivamente emettendo il mio ricevitore quando spostavo gli stick da completamente a sinistra a completamente a destra (impostazioni standard nel TX). Sembrava che -100% corrisponda a impulsi con una lunghezza di 600µs e +100% a 1600µs. Inoltre, non mi interessava la lunghezza degli impulsi di pausa (400 µs) nel mio codice Arduino, ma ho ipotizzato una spaziatura tra i frame di min. 3000µs.

Passaggio 3: configurazione del trasmettitore

Poiché è necessario conoscere solo la posizione effettiva delle superfici di controllo, è sufficiente un canale / "servo" per funzione RC. Di conseguenza, è possibile realizzare una configurazione del trasmettitore piuttosto semplice, simile a un normale modello RC. Le funzioni principali alettone, elevatore, timone e acceleratore richiedono ciascuna un solo servo rispettivamente il canale del trasmettitore. Ho anche aggiunto flap, freni e cambio, lasciando finora 9 canali liberi. Si prega di notare che i flap sono stati messi in una fase di volo e non sono controllati direttamente tramite uno stick, un cursore o un pulsante.

Passaggio 4: eseguire il joystick

La libreria Joystick è abbastanza facile da usare e fornisce alcuni esempi e test. Dovrebbe essere utile verificare prima se Arduino viene rilevato come Joystick corretto, le istruzioni collegate nella sezione di ingresso e la libreria stessa forniscono una buona guida.

Nel pannello di controllo Dispositivi e stampanti, Arduino veniva visualizzato come "Sparkfun Pro Micro" e la finestra di test del joystick mostrava 7 assi e molti pulsanti supportati. Anche un interruttore cappello può essere utilizzato quando programmato in Arduino.

Passaggio 5: codifica di Arduino

Quello che ancora manca è l'effettivo parsing del segnale PPM e l'assegnazione agli assi e ai pulsanti del Joystick. Ho deciso per la seguente mappatura:

Assegnazione canale / funzione / joystick:

1. Acceleratore -> Asse dell'acceleratore
2. Alettoni -> Asse X
3. Ascensore -> Asse Y
4. Timone -> Asse di rotazione X
5. Flap -> Asse di rotazione Y
6. Freno -> Asse Z
7. Ingranaggio -> Pulsante 0

Quando la marcia è abbassata, il primo pulsante del Joystick deve essere premuto e verrà rilasciato quando si alza la marcia. Tuttavia, ciò richiederà FSUIPC per FSX, fuori dalla scatola, FSX accetterà solo un pulsante per attivare la marcia, che non è esattamente ciò che sta accadendo con i miei modelli.

Ho fornito la mia versione attuale del codice con molti commenti, che funziona abbastanza bene per me - sentiti libero di cambiare il tuo compito o aggiungere nuove funzioni. Gli ultimi 9 canali RC non sono attualmente utilizzati.

Per il setup è necessario inizializzare la classe Joystick, sostanzialmente definendo gli intervalli degli assi numerici:

/* Imposta l'intervallo degli assi (definito nell'intestazione, 0 - 1000) */

Joystick.setXAxisRange(CHANNEL_MIN, CHANNEL_MAX); Joystick.setYAxisRange(CHANNEL_MIN, CHANNEL_MAX); …

Utilizzando i valori da 0 a 1000, è possibile mappare direttamente la lunghezza dell'impulso (600 - 1600µs) ai valori del joystick senza ridimensionamento.

Il DIN 3 è inizializzato come ingresso digitale, pullup abilitati e un interrupt collegato:

pinMode(PPM_PIN, INPUT_PULLUP);

attachInterrupt(digitalPinToInterrupt(PPM_PIN), PPM_Pin_Changed, CHANGE);

A scopo di debug, ho aggiunto alcune stampe tramite l'interfaccia seriale a intervalli regolari, utilizzando la libreria arduino-timer:

if(SERIAL_PRINT_INTERVAL > 0) {

scheduler.every(SERIAL_PRINT_INTERVAL, (void*) -> bool { SerialPrintChannels(); return true; }); }

L'interrupt del pin verrà chiamato ogni volta che il valore logico del pin è cambiato, quindi per ogni fronte nel segnale PPM. Valuta la lunghezza dell'impulso semplicemente cronometrando usando micros():

uint32_t curTime = micros();

uint32_t pulseLength = curTime - edgeTime; uint8_t curState = digitalRead(PPM_PIN);

Valutando lo stato del pin attuale e combinandolo con la lunghezza dell'impulso e gli impulsi passati, è possibile classificare i nuovi impulsi. Il seguente condizionale rileverà il gap interframe:

if(lastState == 0 && pulseLength > 3000 && pulseLength < 6000)

Per gli impulsi successivi, la lunghezza dell'impulso verrà mappata su uno stato dell'asse ritagliando e polarizzando la lunghezza dell'impulso in modo che corrisponda all'intervallo dell'asse del joystick:

uint16_t rxLength = pulseLength;

rxLength = (rxLength > 1600) ? 1600: rxLunghezza; rxLength = (rxLength < 600) ? 600: rxLunghezza; rxChannel[curChannel] = rxLength - 600;

L'array rxChannels alla fine contiene 16 valori da 0 a 1000, che indicano le posizioni di stick/slider e pulsanti.

Dopo aver ricevuto 16 canali, viene eseguita la mappatura al Joystick:

/* assi */

Joystick.setThrottle(channels[0]); Joystick.setXAxis(channels[1]); Joystick.setYAxis(1000 - canali[2]); Joystick.setRxAxis(canali[3]); Joystick.setRyAxis(channels[4]); Joystick.setZAxis(1000 - canali[5]); /* pulsanti */ Joystick.setButton(0, (canali[6] < 500 ? 1: 0)); /* aggiorna i dati tramite USB */ Joystick.sendState();

Ho invertito alcuni assi nel codice, il che non è assolutamente necessario, poiché l'asse può anche essere invertito invertendo la direzione del servo o l'assegnazione in FSX. Tuttavia, ho deciso di mantenere le direzioni dei servi e anche l'assegnazione originale dell'FSX.

Il pulsante viene attivato o disattivato tramite la soglia del canale 7.

E non dimenticare di spuntare lo scheduler…altrimenti, nessuna stampa di debug sarà visibile.

ciclo vuoto() {

schedulatore.tick(); }

Nello screenshot che ho allegato puoi vedere, il canale 1 è stato spostato da 1000 (a tutto gas) a 0 (inattivo).

FSX rileverà Arduino proprio come qualsiasi altro Joystick, quindi assegna semplicemente il pulsante e gli assi e divertiti a decollare!

Quello che mi piace davvero di questo approccio è che puoi semplicemente usare il tuo trasmettitore come con un modello reale, ad es. utilizzando fasi di volo ecc.