Conversor PPM para USB Joystick baseado em Arduino (JETI) para FSX: 5 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Decidi mudar meu transmissor JETI DC-16 do Modo 2 para o Modo 1, que basicamente muda o acelerador e o elevador da esquerda para a direita e vice-versa. Já que eu não queria travar um dos meus modelos devido a alguma confusão esquerda / direita no meu cérebro, eu queria saber se é possível praticar um pouco no FSX.

Eu li e testei os transmissores JETI que realmente suportam um modo Joystick fora da caixa, no entanto, eu queria flexibilidade total para as atribuições de eixos e interruptores e usar o TX como um modelo real. Usando a saída do receptor, também é possível alavancar o processamento do sinal no DC-16 e usar mixers, fases de voo, taxas duplas, tudo o que você pode programar lá.

Recentemente, encontrei um bom tutorial sobre como fazer um dispositivo de entrada USB HID, ou seja, um Joystick, a partir de um Arduino barato como um Pro Micro:

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

Isso possibilitaria tudo o que é necessário para controlar um avião / helicóptero / qualquer coisa no FSX! Muitos eixos e botões disponíveis.

Como eu tinha apenas um JETI RSAT2 sobressalente, decidi conectá-lo ao Arduino e tentar implementar um pequeno analisador PPM junto com a biblioteca Joystick.

Presumo que qualquer pessoa que siga essas etapas esteja familiarizada com a conexão e a programação de um Arduino. Não tomarei nenhuma garantia por avarias ou danos!

Suprimentos

Você vai precisar …

• qualquer Arduino compatível com a biblioteca Joystick, usei um Sparkfun Pro Micro 5V / 16 MHz
• uma versão recente do Arduino IDE
• qualquer receptor RC emitindo um sinal PPM, como o JETI RSAT2
• alguns fios de ligação (mín. 3)
• a biblioteca Joystick instalada no Arduino IDE
• a biblioteca arduino-timer:

Etapa 1: conecte o RX e o Arduino

A fiação é bastante simples. Decidi alimentar o Arduino apenas via USB, já que ele deve emular um dispositivo Joystick. Isso fornecerá 5 V ao Arduino, que também pode ser usado para alimentar o receptor RC.

Eu usei o Pin VCC, que fornece saída regulada, e o pino Gnd mais próximo - basta conectá-lo aos pinos + e - do conector do PPM. Quando o Arduino é ligado, o receptor também está ligando.

Para o sinal PPM, decidi usar interrupções para analisá-los. As interrupções estão disponíveis, por exemplo no pino 3, então apenas conecte-o lá - não há "pino RC nativo" no arduino, mas possivelmente mais e diferentes maneiras de ler o sinal do receptor.

Tive que desabilitar o alarme de voltagem RX, já que a voltagem do VCC com alimentação USB será em torno de 4,5 V apenas - mas bastante estável, sem problemas.

Etapa 2: Obter alguns sinais PPM

Quando o receptor E o TX estão ligados, eu estava recebendo sinais PPM como mostrado na imagem. 16 canais, repetidos para sempre. Se o Failsafe no RSAT estiver desabilitado e o transmissor desligado, a saída PPM será desabilitada.

Mais informações sobre PPM estão disponíveis aqui:

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

Como não estou voando com coisas reais neste caso, não me importei com os tempos teóricos e apenas descobri no osciloscópio o que meu receptor estava emitindo de forma aguda ao mover os manípulos totalmente da esquerda para a direita (configurações padrão no TX). Parecia que -100% corresponde a pulsos com comprimento de 600 µs e + 100% a 1600 µs. Eu também não me importei com o comprimento dos pulsos de pausa (400 µs) em meu código Arduino, mas assumi um espaçamento de quadro de min. 3000µs.

Etapa 3: Configurando o Transmissor

Visto que apenas a posição real das superfícies de controle precisa ser conhecida, um canal / "servo" por função RC é suficiente. Consequentemente, uma configuração de transmissor bastante simples pode ser feita - semelhante a um modelo RC normal. As funções principais aileron, profundor, leme e acelerador requerem, cada uma, apenas um servo, respectivamente, canal transmissor. Também adicionei flaps, freios e marcha, deixando 9 canais livres até agora. Observe que os flaps foram colocados em uma fase de vôo e não são controlados diretamente por meio de um manche, controle deslizante ou botão.

Etapa 4: executando o joystick

A biblioteca Joystick é muito fácil de usar e fornece alguns exemplos e testes. Deve ser útil primeiro verificar se o Arduino foi detectado como um Joystick adequado, as instruções vinculadas na seção de entrada e a própria biblioteca fornecem algumas boas orientações.

No painel de controle Dispositivos e Impressoras, o Arduino estava aparecendo como "Sparkfun Pro Micro", e a janela de teste do joystick mostrava 7 eixos e vários botões compatíveis. Até mesmo uma chave de chapéu pode ser usada quando programada no Arduino.

Etapa 5: codificando o Arduino

O que ainda está faltando é a análise real do sinal PPM e a atribuição aos eixos e botões do Joystick. Decidi pelo seguinte mapeamento:

Atribuição de canal / função / joystick:

1. Acelerador -> Eixo do acelerador
2. Aileron -> eixo X
3. Elevador -> eixo Y
4. Leme -> eixo de rotação X
5. Flaps -> eixo de rotação Y
6. Freio -> eixo Z
7. Engrenagem -> Botão 0

Quando a marcha está abaixada, o primeiro botão do Joystick deve ser pressionado e liberado ao aumentar a marcha. No entanto, isso exigirá FSUIPC para FSX, fora da caixa, FSX aceitará apenas um botão para alternar a marcha, o que não é exatamente o que está acontecendo com meus modelos.

Forneci muitos comentários à minha versão atual do código, o que está funcionando muito bem para mim - sinta-se à vontade para alterar sua atribuição ou adicionar novas funções. Os últimos 9 canais RC não são usados atualmente.

Para a configuração, a classe Joystick precisa ser inicializada, basicamente definindo os intervalos numéricos dos eixos:

/ * Definir intervalo de eixos (definido no cabeçalho, 0 - 1000) * /

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

Usando valores de 0 a 1000, é possível mapear diretamente o comprimento do pulso (600 - 1600 µs) para os valores do joystick sem redimensionar.

O DIN 3 é inicializado como entrada digital, pullups habilitados e uma interrupção anexada:

pinMode (PPM_PIN, INPUT_PULLUP);

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

Para fins de depuração, adicionei algumas impressões por meio da interface Serial em intervalos regulares, usando a biblioteca arduino-timer:

if (SERIAL_PRINT_INTERVAL> 0) {

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

A interrupção do pino será chamada sempre que o valor lógico do pino mudar, portanto, para cada borda do sinal PPM. Avalie a duração do pulso apenas por tempo simples usando micros ():

uint32_t curTime = micros ();

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

Avaliando o estado do pino atual e combinando-o com o comprimento do pulso e pulsos anteriores, os novos pulsos podem ser classificados. O seguinte condicional detectará a lacuna entre quadros:

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

Para os pulsos subsequentes, o comprimento do pulso será mapeado para um estado do eixo cortando e enviando o comprimento do pulso para corresponder ao intervalo do eixo do joystick:

uint16_t rxLength = pulseLength;

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

A matriz rxChannels eventualmente contém 16 valores de 0 a 1000, indicando as posições do manípulo / controle deslizante e do botão.

Depois de receber 16 canais, o mapeamento para o Joystick é executado:

/* machados */

Joystick.setThrottle (canais [0]); Joystick.setXAxis (canais [1]); Joystick.setYAxis (1000 - canais [2]); Joystick.setRxAxis (canais [3]); Joystick.setRyAxis (canais [4]); Joystick.setZAxis (1000 - canais [5]); / * botões * / Joystick.setButton (0, (canais [6] <500? 1: 0)); / * atualizar dados via USB * / Joystick.sendState ();

Eu inverti alguns eixos no código, o que não é absolutamente necessário, já que o eixo também pode ser invertido invertendo a direção do servo ou a atribuição no FSX. No entanto, decidi manter as direções do servo e também a atribuição do FSX original.

O botão é ligado ou desligado pelo canal 7 de limiar.

E não se esqueça de marcar o agendador … caso contrário, nenhuma impressão de depuração ficará visível.

void loop () {

scheduler.tick (); }

Na imagem que anexei, você pode ver, o canal 1 foi movido de 1000 (aceleração total) para 0 (ocioso).

O FSX detectará o Arduino como qualquer outro joystick, então apenas atribua o botão e os eixos e divirta-se decolando!

O que eu realmente gosto nessa abordagem é que você pode usar seu transmissor como se fosse um modelo real, por exemplo, usando fases de voo etc.