Geekly articles weekly

FPV-Rennen auf einem Simulator (wir machen einen USB-Joystick von einer Funkfernbedienung)

Der Winter in den nördlichen Breiten ist die Zeit, in der der FPV-Pilot Zeit hat, eine Pause von Rennen und ständigen Pannen einzulegen, einen Lötkolben zu nehmen und etwas Nützliches für sein Hobby herzustellen.

Da es kalt ist, draußen zu fliegen, werden wir die Pilotenfähigkeiten auf Simulatoren trainieren. Dazu müssen Sie Ihr Funkgerät über einen speziellen Adapter an den Computer anschließen, der das PPM-Signal von der Fernbedienung in die vom Computer verstandenen USB-Joystick-Signale umwandelt. Solche Adapter sind natürlich keine Seltenheit und kosten in chinesischen Geschäften einen Cent. Die Lieferung der Bestellung muss jedoch lange warten. Funktioniert sie wie erwartet? Zum Beispiel habe ich diese:

Aus irgendeinem Grund, den ich noch nicht verstanden habe, weigert er sich rundweg, im FPV-Freerider- Simulator angemessen zu kalibrieren , obwohl er in Phoenix RC und Aerofly RC 7 gut funktioniert. FPV-Freerider vermittelt die Physik des Akro-Flugs auf einem Renn-Copter recht gut und außerdem hat einen kostenlosen Demo-Modus.

Gelöst - wir machen den Adapter selbst!

Ein bisschen Ausrüstung:

Die meisten mehr oder weniger seriösen RC-Geräte verfügen über einen Anschluss, über den Steuersignale im PPM-Format (Pulse Position Modulation) ausgegeben werden. Ein PPM-Signal ist eine Folge von kurzen Impulsen, deren Intervall den Steuerwert jedes Kanals der Funkausrüstung bestimmt.
Die Essenz von PPM vermittelt perfekt das Bild:


Um PPM zu dekodieren, müssen Sie die Zeitintervalle zwischen aufeinanderfolgenden Impulsen genau messen (es spielt keine Rolle, zwischen welchen Flanken: vorne oder hinten, da die Dauer der Impulse selbst immer gleich ist).

Implementierung:

Lassen Sie sich von einem Artikel von AlexeyStn über die Erstellung eines PPM-zu-USB-Adapters inspirieren, der auf STM32F3Discovery basiert, aber nur Arduino Pro Micro (Leonardo) mit USB-Hardwareunterstützung enthält. Beginnen wir einen einfachen Weg zu unserem Adapter.

Auf dem Github finden Sie mehrere ähnliche Projekte, und für einige ist nicht einmal Hardware-USB im Controller erforderlich. Die meisten von ihnen müssen jedoch ernsthaft mit einer Datei fertig sein, damit etwas funktioniert. Das passende Projekt war rc-leonardo-joy, die fast unmittelbar nach dem Ausfüllen der Skizze zu funktionieren begann, aber sofort einige Mängel aufwies: Alle Joystick-Messwerte waren nicht sehr stabil - die Cursormarkierung im Bedienfeld tanzte die ganze Zeit um den Sollwert. Ich kann nicht sagen, dass dies das Handling im Simulator erheblich beeinflusst hat, aber wir möchten mit guter Ausrüstung trainieren!

Nun, wir steigen in den Code ein und sehen: Die Berechnung der PPM-Impulsbreite erfolgt durch Verarbeiten eines externen Interrupts und Messen der Intervalle zwischen Aufrufen der Funktion micros () :

void rxInt(void) {
  uint16_t now,diff;
  static uint16_t last = 0;
  static uint8_t chan = 0;

  now = micros();
  sei();
  diff = now - last;
  last = now;
  if(diff>3000) chan = 0;
  else {
    if(900<diff && diff<2200 && chan<RC_CHANS ) {
      rcValue[chan] = adjust(diff,chan);
    }
    chan++;
  }
}

Weitere Informationen zur Funktion micros () finden Sie in der Arduino-Dokumentation:

Gibt die Anzahl der Mikrosekunden zurück, seit das Arduino-Board das aktuelle Programm ausgeführt hat. Diese Zahl läuft nach ca. 70 Minuten über (auf Null zurück). Auf 16-MHz-Arduino-Karten (z. B. Duemilanove und Nano) hat diese Funktion eine Auflösung von vier Mikrosekunden (dh der zurückgegebene Wert ist immer ein Vielfaches von vier). Auf 8-MHz-Arduino-Karten (z. B. dem LilyPad) hat diese Funktion eine Auflösung von acht Mikrosekunden.

Das heißt, die Funktion ist nicht nur nicht besonders genau und gibt immer Werte zurück, die ein Vielfaches von 4 μs sind, sondern läuft auch nach 70 Minuten über, was uns eine Art gekrümmten Wert des gemessenen Intervalls gibt. Nicht gut. Es wäre besser, einen Timer und seine Interrupts zu verwenden, um externe Signale zu erfassen.

Wir schauen weiter: Die meisten Daten zur Position des Joysticks sind künstlich auf ein Byte (0-255) beschränkt:
// Convert a value in the range 1000-2000 to 0-255
byte stickValue(int rcVal) {
  return map( constrain(rcVal - 1000, 0, 1000), 0, 1000, 0, 255);
}

Hmm, ich möchte genauer sein. Dazu müssen Sie jedoch den HID-Deskriptor neu schreiben und alle zugehörigen Datentypen korrigieren.

Kaum gesagt als getan!
Wir teilen das Repository auf und schreiben den Code neu, um mithilfe eines Timers die PPM-Intervalle zu zählen:
void initTimer(void) { 
	// Input Capture setup
	// ICNC1: =0 Disable Input Capture Noise Canceler to prevent delay in reading
	// ICES1: =1 for trigger on rising edge
	// CS11: =1 set prescaler to 1/8 system clock (F_CPU)
	TCCR1A = 0;
	TCCR1B = (0<<ICNC1) | (1<<ICES1) | (1<<CS11);
	TCCR1C = 0;

	// Interrupt setup
	// ICIE1: Input capture 
	TIFR1 = (1<<ICF1); // clear pending
	TIMSK1 = (1<<ICIE1); // and enable
}
...

ISR(TIMER1_CAPT_vect) {
	union twoBytes {
		uint16_t word;
		uint8_t  byte[2];
	} timeValue;

	uint16_t now, diff;
	static uint16_t last = 0;
	static uint8_t chan = 0;
	
	timeValue.byte[0] = ICR1L;    // grab captured timer value (low byte)
	timeValue.byte[1] = ICR1H;    // grab captured timer value (high byte)

	now = timeValue.word;
	diff = now - last;
	last = now;

	//all numbers are microseconds multiplied by TIMER_COUNT_DIVIDER (as prescaler is set to 1/8 of 16 MHz)
	if(diff > (NEWFRAME_PULSE_WIDTH * TIMER_COUNT_DIVIDER)) {
		chan = 0;  // new data frame detected, start again
	}
	else {
		if(diff > (MIN_PULSE_WIDTH * TIMER_COUNT_DIVIDER - THRESHOLD) 
			&& diff < (MAX_PULSE_WIDTH * TIMER_COUNT_DIVIDER + THRESHOLD) 
			&& chan < RC_CHANNELS_COUNT) 
		{
			rcValue[chan] = adjust(diff, chan); //store detected value
		}
		chan++; //no value detected within expected range, move to next channel
	}
}

Erhöhen Sie die Intervalle für die Stick-Abweichung im HID-Deskriptor auf 0-1000:
	// Joystick
	0x05, 0x01,			// USAGE_PAGE (Generic Desktop)
	0x09, 0x04,			// USAGE (Joystick)
	0xa1, 0x01,			// COLLECTION (Application)
	0x85, JOYSTICK_REPORT_ID,	//   REPORT_ID (3)
	...
	0xA1, 0x00,		    //   COLLECTION (Physical)
	0x09, 0x30,		    //     USAGE (x)
	0x09, 0x31,		    //     USAGE (y)
	0x09, 0x33,		    //     USAGE (rx)
	0x09, 0x34,		    //     USAGE (ry)
	0x15, 0x00,		    //	   LOGICAL_MINIMUM (0)
	0x26, 0xE8, 0x03,	    //     LOGICAL_MAXIMUM (1000)
	0x75, 0x10,	  	    //	   REPORT_SIZE (16)
	0x95, 0x04,		    //     REPORT_COUNT (4)
	0x81, 0x02,		    //     INPUT (Data,Var,Abs)
	0xc0,			    //   END_COLLECTION

	0xc0				// END_COLLECTION

Ändern Sie auf dem Weg uint8_t in uint16_t, wo immer die Stick-Abweichungswerte übertragen werden.
Wir entfernen den zusätzlichen Code, fügen ein Dutzend #define hinzu und erhalten eine gute Skizze, die geschärft ist, um als PPM-USB-Adapter zu funktionieren.

Das Ergebnis ist in github verfügbar: github.com/voroshkov/Leonardo-USB-RC-Adapter

Skizzeneinstellungen:

Es ist sinnvoll, die Definition für futaba zu entfernen, wenn Sie andere Hardware haben:
#define FUTABA

und passen Sie gegebenenfalls die Werte von Mikrosekunden in den Parametern an, wenn Ihr Gerät andere Timings erzeugt:
#define STICK_HALFWAY 500
#define STICK_CENTER 1500
#define THRESHOLD 100


Zusammenstellung:

Um die Skizze zu kompilieren und hochzuladen, müssen Sie die USB-Bibliotheken in der Arduino-Umgebung selbst ersetzen, nachdem Sie Backups erstellt haben.
Dazu gehen wir auf dem Weg in den Darm von Arduino ... \ Arduino \ hardware \ arduino \ cores \ arduino \ , sichern usbapi.h und hid.cpp und überschreiben sie anschließend mit denselben Dateien aus dem ArduinoLibs- Ordner des Repositorys. Öffnen Sie als nächstes die Skizze, verbinden Sie den Arduino Leonardo und füllen Sie ihn aus.

Verbindung:

Alles ist hässlich einfach: Einerseits stecken wir USB ein, andererseits löten wir zwei Drähte (an Digital Pin 4 und Masse) und stecken sie in das PPM bzw. die Masse des Senders. Es stellt sich irgendwie so heraus:

In Windows 7 wird das Gerät als Composite (Tastatur, Maus, Joystick) mit dem Namen Arduino Leonardo erkannt.

Besondere Erwähnung verdient den Stecker im Gerät. Irgendwo ist es eine normale Audio-Buchse, und irgendwo (wie in meiner Futaba 7C) ist etwas schwieriger:


Für die Montage verschiedener "männlicher" Steckverbinder verwende ich seit langem erfolgreich Heißkleber. Dazu legen wir Papier oder Polyethylen auf die „Mutter“, durchstechen dieses Substrat mit Stiften, so dass sie in den Anschluss auf der anderen Seite stecken, und gießen dann allmählich Klebstoff zwischen die Stifte, um ihm gleichzeitig mit nassen Fingern Form zu geben. Die Drähte müssen natürlich im Voraus gelötet werden, damit der ausgehärtete Klebstoff beim Löten nicht schmilzt. Es stellt sich nicht immer ästhetisch heraus, aber sehr funktional:

(Hier im Stecker werden 4 Stifte für die eindeutige Positionierung benötigt, es gibt nur zwei Arbeiter.)

Das ist alles. Wir laden den Simulator herunter, schließen die Ausrüstung an und trainieren die Pilotenfähigkeiten, während wir an dunklen Winterabenden heißen Tee vor dem Kamin trinken.

PS

Was ist, wenn es keinen Arduino Leonardo gibt, aber auf dem STM32F103C8T6 ein solches Minimum Development Board vorhanden ist?

Mach dir keine Sorgen, den ganzen Weg. Sowohl für Sie als auch für meine eigene Entwicklung habe ich das bereits erwähnte Projekt von Alexey Stankevich portiert .
Quellen und kompilierte Binärdateien zum Hochladen auf diesen Controller finden Sie hier: github.com/voroshkov/STM32-RC-USB-Adapter .

Ich werde alle Fragen gerne in den Kommentaren beantworten.

Habt einen schönen Flug!

Source: https://habr.com/ru/post/de388811/

More articles:


All Articles