Thesis

Aufbau und Test eines Hexacopters
Projekt 6 - Fachbericht
Autor: Tobias Bernot
Auftraggeber : Nouri T. Prof. Dr. Dip. Eng. Elec./Phys
Betreuer : Nouri T. Prof. Dr. Dip. Eng. Elec./Phys
Semester : SoSe 16
Fassung: V1.02
1
Zusammenfassung
Diese Bachelorthesis ist über der Erweiterung einer Drohne mit einer Fahrtmöglichkeit. Die
Erweiterung ist hauptsächlich Software aber die Drohen wird auch mit Hardware erweitert.
Um Software-seitig die Drohne auf die Fahrt vorzubereiten soll die Drohne einen neuen Modi
erlernen. In Diesen Modi soll die Drohne Zwei Motoren mit unterschiedlichen Geschwindigkeiten Steuern um ihre Richtung und Geschwindigkeit zu bestimmen. Die Drohne wird dabei die
Richtung und Geschwindigkeit von der Fernsteuerung erhalten.
Hardware-Seitig werden Zwei Arme umgebaut, um Räder auf den Boden zu Tragen. Ein Vorderrad wird auch aufgebaut, als Stütze.
Keywords : Drohne, Kopter, 3D Robotics, Fahrt, Ardupilot, Arducopte, AP,
Motors
3
Danksagung
Ich möchte mich bei Herrn Prof. Dr. Nouri bedanken, der dieses interessante Projekt ermöglicht
hat. Ich möchte mich auch bei Herrn Prof. Dr. Maurico bedanken, der mir mit seinen Rat
sehr geholfen hat. Mein Dank gilt auch der FHNW, der HFU und der UHA für meine ICS
Ausbildung, die mich zu diesem Projekt geführt hat.
5
Inhaltsverzeichnis
1. Einleitung
9
2. Projektumfeld
2.1. Hardware . . . . . . . . . .
2.2. Software . . . . . . . . . . .
2.2.1. Firmware . . . . . .
2.2.2. Computer Programm
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3. Ziele
11
11
11
11
12
13
3.1. Muss-Ziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.2. Wunsch-Ziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.3. Nicht-Ziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4. Konzepte
4.1. Reaktoren / Propeller
4.2. Motoren auf die Räder
4.2.1. Steering . . . .
4.2.2. Skid Steering .
4.3. Auswahl . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5. Planung
15
15
15
15
15
15
17
5.1. Zeitplan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5.2. Projektverlauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6. Fahrmodusimplementierung
6.1.
6.2.
6.3.
6.4.
6.5.
Fahrmodus Datei . . . . . . . . . . . . . . . . . . . .
Hinzufügen des Fahrmodus . . . . . . . . . . . . . . .
Aktivierung von Motoren im Fahrmodus ermöglichen
Modiwechsel-Sicherung . . . . . . . . . . . . . . . . .
Änderung der Modi-Auswahl von CH5 . . . . . . . .
7. Fahrimplementierung
7.1. Möglichkeiten . . . . . . . . . . . . . . . .
7.1.1. Register . . . . . . . . . . . . . . .
7.1.2. Mit RC_channel . . . . . . . . . .
7.1.3. Motor-Matrix . . . . . . . . . . . .
7.2. Motor-Matrix . . . . . . . . . . . . . . . .
7.2.1. Deaktivierung der Grund-Motoren .
7.2.2. Berechnung der Ausgangsleistung .
7.2.3. Balance . . . . . . . . . . . . . . .
7.2.4. Beobachtung . . . . . . . . . . . .
7.3. RC Channel . . . . . . . . . . . . . . . . .
7.3.1. Skid Steering . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
19
19
19
22
22
23
25
25
25
25
25
25
26
27
27
28
28
28
7
Inhaltsverzeichnis
7.3.2. Frame-Portabilität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
7.3.3. Entschärfen der Motoren . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
7.3.4. Motor-Balance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8. Hardware
8.1. Material . . . . . . . . . . . . . . . .
8.2. Aufbau . . . . . . . . . . . . . . . . .
8.2.1. Drittes Rad . . . . . . . . . .
8.2.2. Konzept : Motorisierte Räder
8.3. Konzept : Motorisierte Propeller . . .
8.3.1. Wechsel zu den Propellern . .
8.3.2. Propeller und Motoren . . . .
8.3.3. Räder . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
10.1. Fahrmodus . . . . . . . . . . . . . . .
10.1.1. Wechseln zu dem neuen Modus
10.1.2. Modi wechseln . . . . . . . . . .
10.1.3. Motoren Scharf Machen . . . .
10.1.4. Flugsicherung . . . . . . . . . .
10.2. Fahrimplementierung . . . . . . . . . .
10.2.1. Motor-Matrix-Implementierung
10.2.2. Balance . . . . . . . . . . . . .
10.2.3. RC Channel Implementierung .
10.2.4. Balance . . . . . . . . . . . . .
10.3. Hardware-Tests . . . . . . . . . . . . .
10.3.1. Räder mit Motorantrieb . . . .
10.3.2. Propeller mit Motoren . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9. Tests
9.1.
9.2.
9.3.
9.4.
Test-Methodik . . . . . . .
Fahrmodus . . . . . . . .
Fahrimplementierung . . .
Rad- / Propeller-Montage
.
.
.
.
10.Ergebnisse
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
31
31
31
31
31
32
32
32
32
33
33
33
33
33
35
35
35
35
35
35
35
35
36
36
37
37
37
37
11.Reexion
39
12.Ehrlichkeitserklärung
41
A. Codequelle
45
B. IDE
47
C. Nützliche Informationen
49
C.1. Fernsteuerung Mapping . . . . . . . . . .
C.2. Bedienung von Ladegerät X80 imaxRC .
C.3. APMplanner Bedienung und Installation
C.3.1. Installation . . . . . . . . . . . .
C.3.2. Bedienung . . . . . . . . . . . . .
D. Pichtenheft für Bachelorthesis
8
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
49
49
50
50
51
53
1. Einleitung
Drohnen kommen immer öfters zum Einsatz, sei es um Pakete zu liefern oder um Bilder zu
nehmen. Am bekanntesten sind Flugdrohnen. Diese Fortbewegungsmethode verbraucht jedoch
viel Energie.
Eine Alternative zu diese Fortbewegungsmethode wäre Fahren.
Bei Diesen Projekt wird eine Fliegende Drohne erweitert, damit sie sowohl Fahren als auch
Fliegen kann. Dabei wird einen Hexacopter mit einen APM2 verändert. Die Veränderungen
betreen hauptsächlich die Firmware, Arducopter, aber die Drohne wird auch für das Fahren
vorbereitet.
9
2. Projektumfeld
Das Projekt betrit vorwiegend das Programmierern der Drohne. Etwas Mechanik wird auch
behandelt, hauptsächlich für die Montage der Drohne auf Räder.
2.1. Hardware
Eine iegende Drohne mit einen APM 2.0 als Controller soll mit einer Fahrtmöglichkeit erweitert
werden.
Abbildung 2.1.: apm2
Die Drohne besteht aus einer Kreuz Struktur, mit 6 Antrieben, dies wird im Verlauf geändert.
Abbildung 2.2.: Struktur der Drohne [1]
2.2. Software
2.2.1. Firmware
Die Drohne läuft mit den Arducopter Firmware.
Diese ist in C++ programmiert, die Firmware Steuert die Motoren, überprüft Sensoren wie den
GPS.
11
2. Projektumfeld
Ardupilot ist de Grundsoftware, die für Planes, Rovers, und Copter jeweils mit ein paar Änderungen adaptiert wurde.
Eine Ardupilot Software ist leicht erweiterbar für jedes Bedürfnis und kann auch die Drohne
durch Zielpunkte führen oder andere Aktoren betätigen. So kann man auch die Drohne fernsteuern oder selbständig iegen lassen.
Abbildung 2.3.: APM Logo, für die Ardupilot Software.
2.2.2. Computer Programm
Computer-seitig wird diese von der APMplaner2 gesteuert, eine Software zum Initialisieren von
Drohnen, und zum Planen von Missionen. Auch das automatische Verhalten von der Drohe
wird dort eingestellt. Das Programm läuft auf Windows, Linux so wie Mac.
Abbildung 2.4.: APMplaner2, Flight data Ansicht, in Windows.
12
3. Ziele
Dieses Projekt hat drei Kategorien von Zielen : Muss-Ziele, Wunsch-Ziele und Nich- Ziele
3.1. Muss-Ziele
* Fertige Implementierung vom Fahrmodus in der Firmware
* Fahrmodus Integration im APM
* Bestimmung, Bestellung und Einbau von notwendigen mechanischen Teilen für die Fahrt
* Dokumentation, Poster, Website
Fahrmodus Integration im APM
Das APM ermöglicht das planen von benutzen Von Fahrmodi je nach Etappe, und sollte deshalb
auch die Möglichkeit haben die Drohne fahren zu lassen.
Testplanung, Testdurchführung, Testauswertung
Nach jeden Zufügen von neuen Material zur Drohne, sei es eine Implementierung oder Hardware,
wird diese getestet.
3.2. Wunsch-Ziele
3.3. Nicht-Ziele
* Aufbau einer Drohne, eine ist bereits zur Verfügung gestellt.
* Komplette Software für die Drohne entwickeln, ein Open-source Projekt wird erweitert.
* Komplette Software für die Konguration von der Drohne entwickeln, einen Open-source
Projekt wird erweitert.
13
4. Konzepte
Es gibt mehrere Möglichkeiten, um die Drohne auf den Boden bewegen zu können. Hier vorgestellt werden die, die am meisten betrachtet wurden. In allen Fällen werden Räder die Drohne
tragen, aber nicht unbedingt bewegen.
4.1.
Reaktoren / Propeller
Die Räder Trage nicht dazu bei, die Drohne zu bewegen. Die Drohne wird mit der Kraft von
Propellern bewegt. Entweder wird viel Luft langsam bewegt mit Propellern, oder wenig mit
einem Reaktor, dafür aber viel schneller. Mit zwei Propellern oder Reaktoren kann die Richtung
mit einen Leinstungsunterschied gesteuert werden (Skid Steering).
4.2.
Motoren auf die Räder
Die andere Möglichkeit wäre, die Räder zu benutzen, um die Drohne zu bewegen. Zwei Einbaumöglichkeiten wären dafür zu betrachten.
4.2.1.
Steering
Die Richtung wird mit der Richtung der Vorderen Rädern gesteuert, die oft an einen Servomotor
verbunden sind. Die Geschwindigkeit wird von den Hinterrädern gesteuert, die mit einen Motor
verbunden sind.
4.2.2.
Skid Steering
Zwei Räder schieben mit separaten Motoren die Drohne. Die Richtung wird mit einen Leinstungsunterschied von den beiden Motoren gesteuert.
4.3.
Auswahl
Während dieses Projekts wurden beide Möglichkeiten benutzt, da die Erstgewählte später Probleme bereitete.
15
5. Planung
5.1. Zeitplan
Abbildung 5.1.: Zeitplan , ( Datum in US Schreibweise)
Einige Teile des Projekts haben sich sehr verlängert, die Fahrimplementation besonders, und
damit viele teile des Projekts und Termine verschoben.
5.2. Projektverlauf
Das Spiralen-Modell wird benutzt, und jedes Teil des Projekts wird geplant, implementiert,
getestet, und danach erweitert.
Abbildung 5.2.: Spiralen Model nach Boem [2]
17
6. Fahrmodusimplementierung
Der Farhmodus soll zu der Drohne hinzugefügt werden, in diesen Modus soll die Drohne auf
den Boden fahren, und von der Fernsteuerung gesteuert werden.
6.1. Fahrmodus Datei
Für jeden Modus gibt es eine separate Datei, in diesem Fall ist es die control_drive.pde Datei.
Die enthält die Funktionen drive_init und drive_run. drive_init wird nur nach den Wechsel
zum Farhmodus einmal ausgeführt, während drive_run im Fahrmodus mit 100 Hz oder mehr
aufgerufen wird.
6.2. Hinzufügen des Fahrmodus
Der Fahrmodus wurde in der Modus-Liste hinzugefügt, die in der dene.h Datei enthalten ist.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//
Auto
Pilot
modes
−−−−−−−−−−−−−−−−
#define STABILIZE 0
#define ACRO 1
#define ALT_HOLD 2
#define AUTO 3
#define GUIDED 4
#define LOITER 5
#define RTL 6
#define CIRCLE 7
#define LAND 9
#define OF_LOITER 10
#define DRIFT 11
#define SPORT 13
#define FLIP
14
#define AUTOTUNE 15
#define POSHOLD
16
#define NUM_MODES 18
#define DRIVE 17
//
using
no
optical
longer
roll
roll
flow
//
hold
level
position
//
rate
control
// AUTO
control
// AUTO
control
// AUTO
control
//
a
Hold
single
// AUTO
control
// AUTO
control
// AUTO
control
//
Hold
a
//
DRIFT mode
//
earth
//
flip
//
autotune
the
//
position
hold
single
location
location
sensor
( Note :
12
is
used )
frame
the
rate
vehicle
control
on
the
axis
and
pitch
vehicle 's
gains
with
manual
override
Damit der Fahrmodus aufrufen wird, wurde es der ightmode.pde Datei addiert. Um zu dem
Modus wechseln zu können wurde es in set_mode eingefügt, dabei wird init aufgerufen.
static
1
2 {
bool set_mode ( uint8_t mode )
19
6. Fahrmodusimplementierung
3
4
5
//
boolean
to
record
if
flight
mode
could
bool s u c c e s s = f a l s e ;
bool ignore_checks = ! motors . armed ( ) ;
an y
mode
if
disarmed .
We
rely
on
be
//
the
set
allow
arming
switching
check
to
6
7
// r e t u r n i m m e d i a t e l y i f we a r e a l r e a d y i n t h e d e s i r e d mode
8
( mode == control_mode ) {
9
true ;
10
}
11
12
( mode ) {
13
ACRO:
14
# FRAME_CONFIG == HELI_FRAME
15
s u c c e s s = h e l i _ a c r o _ i n i t ( ignore_checks ) ;
16
#
17
s u c c e s s = a c r o _ i n i t ( ignore_checks ) ;
18
#e n d i f
19
;
20
21
STABILIZE :
22
# FRAME_CONFIG == HELI_FRAME
23
s u c c e s s = h e l i _ s t a b i l i z e _ i n i t ( ignore_checks ) ;
24
#
25
s u c c e s s = s t a b i l i z e _ i n i t ( ignore_checks ) ;
26
#e n d i f
27
;
28
29
ALT_HOLD:
30
s u c c e s s = a l t h o l d _ i n i t ( ignore_checks ) ;
31
;
32
33
AUTO:
34
s u c c e s s = a u t o _ i n i t ( ignore_checks ) ;
35
;
36
37
CIRCLE :
38
s u c c e s s = c i r c l e _ i n i t ( ignore_checks ) ;
39
;
40
41 . . .
42
DRIVE:
43
s u c c e s s = d r i v e _ i n i t ( ignore_checks ) ;
44
;
45
46
:
47
success = false ;
48
;
49
}
Im update_ight_mode um den run aufzurufen.
1
update_flight_mode ( )
if
return
switch
case
case
case
case
case
case
if
else
break
if
else
break
break
break
break
break
default
break
static void
20
to
perform
6.2. Hinzufügen des Fahrmodus
2 {
3
( control_mode ) {
4
ACRO:
5
# FRAME_CONFIG == HELI_FRAME
6
heli_acro_run ( ) ;
7
#
8
acro_run ( ) ;
9
#e n d i f
10
;
11
12
STABILIZE :
13
# FRAME_CONFIG == HELI_FRAME
14
heli_stabilize_run () ;
15
#
16
stabilize_run () ;
17
#e n d i f
18
;
19
20
ALT_HOLD:
21
althold_run ( ) ;
22
;
23
24
AUTO:
25
auto_run ( ) ;
26
;
27
28
CIRCLE :
29
circle_run () ;
30
;
31
32 . . .
33
34
DRIVE:
35
drive_run ( ) ;
36
;
37
38
}
39 }
So verfahren wurde auch beim print_ight_mode, damit der APM auf Computer-anfragen
antworten kann.
1
2 print_flight_mode (AP_HAL: : BetterStream ∗ port , uint8_t mode )
3 {
4
( mode ) {
5
STABILIZE :
6
port −>print_P (PSTR( "STABILIZE" ) ) ;
7
;
8
ACRO:
9
port −>print_P (PSTR( "ACRO" ) ) ;
10
;
switch
case
case
case
case
case
case
if
else
break
if
else
break
break
break
break
break
static void
switch
case
break
case
break
21
6. Fahrmodusimplementierung
case ALT_HOLD:
port −>print_P (PSTR( "ALT_HOLD" ) ) ;
break ;
case AUTO:
port −>print_P (PSTR( "AUTO" ) ) ;
break ;
case DRIVE:
port −>print_P (PSTR( "DRIVE" ) ) ;
break ;
default :
port −>printf_P (PSTR( "Mode(%u ) " ) , ( unsigned ) mode ) ;
break ;
11
12
13
14
15
16
17 . . .
18
19
20
21
22
23
24
25
}
26 }
6.3. Aktivierung von Motoren im Fahrmodus ermöglichen
1
2
3
4
5
6
Damit man auch im Fahrmodus starten kann, wurde er zu der Liste der scharfmachenden Modi
hinzugefügt.
bool mode_allows_arming ( uint8_t mode , bool arming_from_gcs ) {
( manual_flight_mode ( mode ) | | mode == LOITER | | mode ==
ALT_HOLD | | mode == POSHOLD | | mode == DRIVE | | (
arming_from_gcs && mode == GUIDED ) ) {
true ;
}
false ;
}
static
if
return
return
6.4. Modiwechsel-Sicherung
Die Drohne soll nicht in den Farhmodi wechseln, solange sie iegt. Dafür wurde eine Überprüfung eingefügt, die Drohne soll fertig gelandet sein, bevor sie fahren kann. Die Drohne überprüft
in der Init des neuen Modus, ob sie gelandet ist.
1
bool d r i v e _ i n i t ( bool ignore_checks )
2 {
3
4
// c o n t r o l e p a r m o t e u r s o u h a i t e e t t e s t v a l u e
5
// A j o u t m o t e u r s o u h a i t e
6
// i m p l e m e n t a t i o n e v e n t u l l e l e m n t a r e n d r e s c a l l a b l e
7
8
// IF l a n d e d −>t r u e
9
( ap . land_complete ) {
10
true ;
11
}
{
12
// e l s e −> f a l s e
13
false ;
static
if
return
else
return
22
6.5. Änderung der Modi-Auswahl von CH5
14
15
16 }
}
6.5. Änderung der Modi-Auswahl von CH5
Mit Apm-Planner wird die Modi-Auswahl von CH5 geändert.
Siehe Abbildung 6.1
Abbildung 6.1.: Wechseln der Parameter in Apmplanner2
23
7. Fahrimplementierung
Die Motoren der Drohne sind mit jeweils einem PWM zu Spannungs-Konverter am APM2
angeschlossen. Die Konverter bei den Versuchen erlaubten es nur in einer Richtung die Motoren
zu drehen, da diese für den Flug gedacht waren. Das Ziel ist es, ein PWM-Signal auf beide
Ausgänge zu generieren. Das Gerät soll mit einen Gleichgewicht von zwei Motoren fahren, eine
Skid Steuerung.
7.1. Möglichkeiten
7.1.1. Register
Direkt mit den Microncotrollerregistern arbeiten, ist Controller spezisch, sehr zeitaufwendig.
Diese Möglichkeit wurde nicht benutzt.
7.1.2. Mit RC_channel
Eine weitere Möglichkeit ist, die RC_Channel Librarys zu benutzen, um die gewollten PWMAusgänge zu steuern. Die BibliothekRC_Channel ist relativ verirrend, da sie für den RC_Eingang
und den PWM-Ausgang benutzt wird.
Abbildung 7.1.: Abweichung vom Standard verlauf mit zugri auf RC_channel
7.1.3. Motor-Matrix
Zusätzliche Motoren für die Motor-Matrix im Programm generieren, und diese separat steuern.
Sehr viel muss reimplementiert werden, da die RC-Librarys-Funktionen nicht zur Verfügung
stehen.
7.2. Motor-Matrix
Die erste Implementierung war, mit der Motor-Matrix zu arbeiten. Die Motor-Matrix ist der
Zugri auf alle Motoren. Um zwei zusätzliche Motoren für die Fahrt zum arbeiten zu bringen,
war es notwendig, diese nur während der Fahrt zu erstellen und auÿerhalb der Fahrt zu löschen.
Auch müssen die Flugmotoren während der Fahrt eingestellt werden. Dies wurde in der Datei
25
7. Fahrimplementierung
Abbildung 7.2.: Abweichung vom Standard verlauf mit zugri auf Motor_Matrix
control_drive.pde implementiert
7.2.1. Deaktivierung der Grund-Motoren
Einer der gröÿten Herausforderungen ist das Löschen der beiden Motoren wenn nicht im
Fahrtmodus. Da sich der Code in der control_drive.pde Datei nur während der Fahrt ausführt, können die Motoren auÿerhalb der Fahrt nicht sinnvoll gelöscht werden. In der Datei
User_Code.pde wird Code in einer bestimmten Frequenz ausgeführt, von 1Hz bis zu 100Hz,
auch Initial-befehle können ausgeführt werden. Dies geschiet in jedem Flugmodus.
Hiermit lieÿen sich die Motoren sinnvoll löschen, jede Sekunde wird überprüft ob die Drohne
im Fahrmodus ist, und falls es nicht mehr so sein sollte, werden die Motoren gelöscht.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#ifdef USERHOOK_SUPERSLOWLOOP
#ifndef AP_MOTORS_MOT_5
#define AP_MOTORS_MOT_5 4
#endif
#ifndef AP_MOTORS_MOT_6
#define AP_MOTORS_MOT_6 5
#endif
void userhook_SuperSlowLoop ( )
{
if ( control_mode !=DRIVE) {
//
remove
unused
Motors
motors . output_test (AP_MOTORS_MOT_5, 1000) ;
motors . output_test (AP_MOTORS_MOT_6, 1000) ;
motors . remove_motor (AP_MOTORS_MOT_5) ;
motors . remove_motor (AP_MOTORS_MOT_6) ;
}
// h a l . c o n s o l e
}
#endif
26
−> p r i n t l n ( "SUPERSLOW
USERHOOK
\n " ) ;
7.2. Motor-Matrix
7.2.2. Berechnung der Ausgangsleistung
Danach müssen die Werte von den Eingang, also RC_input, welches Throttle, Direction,
und Power enthält, zu den zwei Motorleistung umgerechnet werden. Dies wird in den convert_RC_to_Motor_R/L Funktionen realisiert.
1 int16_t convert_RC_to_Motor_R ( int16_t rc_dir , int16_t rc_pow , int16_t
rc_max , int16_t rc_min ) {
2
3
rel_deci = (
) (((
) 2∗(
) rc_dir \
4
− ((
) rc_max + (
) rc_min ) ) \
5
/ ((
) rc_max − (
) rc_min ) ) ;
6
7 int16_t tmp_result = ( int16_t ) ( rc_pow − ( int16_t ) ( (
) rc_pow ∗ (
r e l _ d e c i ) ) ) /2 + rc_min ;
8
9
10
11
( tmp_result>rc_max ) ?( rc_max ) : ( tmp_result ) ;
12 }
13
14
15 int16_t convert_RC_to_Motor_L (
rc_dir ,
rc_pow ,
rc_max ,
rc_min ) {
16
17
rel_deci = (
) (((
) 2∗(
) rc_dir \
18
− ((
) rc_max + (
) rc_min ) ) \
19
/ ((
) rc_max − (
) rc_min ) ) ;
20
tmp_result = ( int16_t ) ( rc_pow + ( int16_t ) ( (
) rc_pow ∗ (
r e l _ d e c i ) ) ) /2 + rc_min ;
21
22
23
( tmp_result>rc_max ) ?( rc_max ) : ( tmp_result ) ;
24 }
float
float
float
float
float
float
float
float
float
return
int
float
int
float
float
float
float
float
float
int
int
int
float
float
return
7.2.3. Balance
Ein weiterer Faktor wird danach berechnet, um die Leistung der beiden Motoren auszugleichen.
Die Funktion addiert oder subtrahiert die Leistung von der Motoren mit den Wert der auf den
6. Kanal gesendet wird.
1 // A d j u s t i n g Motor o u t p u t t o CH6
2 int16_t adjust_ch6 ( int16_t rc_input_6 , int16_t rc_out , bool add ) {
3
int16_t rc_output ;
4
( add ) {
5
rc_output = ( int16_t ) ( rc_out + rc_input_6 )−HALF6;
6
}
7
{
8
rc_output = ( int16_t ) ( rc_out − ( rc_input_6 − HALF6) ) ;
9
}
10
rc_output ;
11 }
if
else
return
27
7. Fahrimplementierung
7.2.4. Beobachtung
Erst nach Implementierung und Test von mehreren Funktionen wurde klar, dass das meiste
unnötig war.
Die Funktionen waren am Anfang recht einfach, aber mit jedem Problem wurden diese unübersichtlicher. Am Ende war der Code nicht mehr weiterzubearbeiten, deswegen wurde eine
Alternative ausprobiert, die schon die meisten Funktionen integriert hatte : RC Channel.
7.3. RC Channel
Die RC_Channel Bibliothek ist für die Drohne der Zugri auf die PWM-Ausgänge und die
Radio-Eingänge. Es gibt mehrere Modi, um einen PWM-Ausgang zu realisieren. Hier sind die
meist-benutzten :
1. range : Limits für den Ausgangs-wert setzen
2. angle : Einen abstrakten 0-angle-Wert setzen, das zum Ausgang konvertiert wird.
Die Konvertierungen von den empfangenen Radio-Werten zu Float-Werten und von einem
Scale-Wert zu den PWM-Ausgangs-Werten werden von der RC_channel Bibliothek gemacht.
7.3.1. Skid Steering
Die Implementation von ArduRover skid steering wurde viel kopiert, da es genau das bezwekte
skid steering zum Zweck hatte. Mit einen Paar Änderungen konnte dies auf diesen besonderen
Einsatz angepasst werden.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// s e t s
ranges
// a l l o w s
/ angle
using
for
channels
output
as
//
servo_out
=
angle
∗ motorX
!
ouput
channel_R−>set_angle ( ( int16_t ) MAXANGLE) ;
channel_L−>set_angle ( ( int16_t ) MAXANGLE) ;
channel_R−>enable_out ( ) ;
channel_L−>enable_out ( ) ;
// c a l c u l a t e
// r e d u c e d
power
0.5
form
for
motors
steering
scaled
to
0.2 ,
to
make
less
violent
turns
15
float motor1 = t h r o t t l e _ s c a l e d
balance_scaled ;
float motor2 = t h r o t t l e _ s c a l e d
16
17
18
19
20
channel_R−>servo_out = ( int16_t ) (MAXANGLE∗ 2/3+ (MAXANGLE/3) ∗ motor1 ) ;
channel_L−>servo_out = ( int16_t ) (MAXANGLE∗ 2/3+ (MAXANGLE/3) ∗ motor2 ) ;
channel_R−>calc_pwm ( ) ;
channel_L−>calc_pwm ( ) ;
// a d d e d
balance
value
balance_scaled ;
28
to
adjust
motor
output
passively
+ 0 . 2 f ∗ s t e e r i n g _ s c a l e d +0.1 f ∗
− 0 . 2 f ∗ s t e e r i n g _ s c a l e d − 0.1 f ∗
7.3. RC Channel
21 hal . c o n s o l e −>printf_P (PSTR( " L : %i , R %i \n" ) , channel_L−>
radio_out , channel_R−>radio_out ) ;
22 // o u t p u t
23 channel_R−>output ( ) ;
24 channel_L−>output ( ) ;
25
26 update_simple_mode ( ) ; // N e e d e d t o c h a n g e modes
Dies vereinfachte das meiste von den Code.
7.3.2. Frame-Portabilität
1
2
3
4
5
6
7
8
9
10
Die Fahrimplementierung wurde exibel gestaltet, damit auch nicht nur Quadcopter-Räder
hinzugefügt werden können, sonder auch Hexacopter, oder TRI-copter. Zwei Methoden kommen dafür im Betracht : Mit Präprozessor-Anweisungen werden je nach Frame-Konguration
bestimmte RC_channels für die Rad-Motoren gewählt. Dies geschieht beim Kompilieren. Diese Lösung wurde später verworfen, als dies mit dem Deaktivieren der Flugmotoren Konikte
herbeiführte.
FRAME_CONFIG == QUAD_FRAME
channel_R = &g . rc_5 ;
channel_L = &g . rc_6 ;
FRAME_CONFIG == HEX_FRAME
channel_R = &g . rc_7 ;
channel_L = &g . rc_8 ;
#if
#elif
#else
channel_R = &g . rc_5 ;
channel_L = &g . rc_6 ;
#endif
Bei der zweiten, und denitiven Lösung werden die Channel 10 und 11 benutzt, die normalerweise für Kamera-Steuerung benutzt werden.
1
channel_R = &g . rc_10 ;
2
channel_L = &g . rc_11 ;
Dadurch wurde auch die Störung und Benutzung von Funktionen, die sich am Präprozessor variable AP_MOTORS_MAX_NUM_MOTORS1 für die Chanel-Auswahl hielten, ausgeschlossen.
7.3.3. Entschärfen der Motoren
Das Ausschalten der Motoren wenn nicht im Fahrmodus wird, wie bei der Motor-Matrix, mit
den user_code.pde2 Datei durchgeführt.
1
USERHOOK_SUPERSLOWLOOP
2
userhook_SuperSlowLoop ( )
3 {
4
// p u t y o u r 1 Hz c o d e h e r e
5
// d e s a c t i v a t e c h a n n e l s when n o t i n u s e
#ifdef
void
1 AP_MOTORS_MAX_NUM_MOTORS
wird benutzt, um die maximale Anzahl an (Flug)-Motoren zu denieren. Üblicherweise sind es 8, diese Variabel wird oft in der Motormatrix-Steuerung benutzt.
29
7. Fahrimplementierung
6
7
8
9
10
11
12
13
14
15
16
17
if ( ( control_mode !=DRIVE)
&& ( g . rc_10 . servo_out != 0 ) ) {
g . rc_10 . servo_out = ( int16_t ) ( 0 ) ;
g . rc_11 . servo_out = ( int16_t ) ( 0 ) ;
g . rc_10 . calc_pwm ( ) ;
g . rc_11 . calc_pwm ( ) ;
g . rc_10 . output ( ) ;
g . rc_11 . output ( ) ;
g . rc_10 . disable_out ( ) ;
g . rc_11 . disable_out ( ) ;
}
7.3.4. Motor-Balance
1
2
3
4
5
6
7
Da die Motoren zum Fahren verschieden von den Flugmotoren sind, müssen diese separat
Balanciert werden.3 Dafür wird der sechste Channel der Fernbedienung benutzt. Dieser Teil
wurde auf den vorherigen Code aufgebaut. Der umgerechnete Wert von dem 6. Kanal wird
zehnfach reduziert und mit den Motor-Ausgängen addiert oder subtrahiert.
RC_Channel ∗ channel_balance ;
channel_balance = &g . rc_6 ;
...
balance_scaled = channel_balance −>norm_input ( ) ;
...
motor1 = t h r o t t l e _ s c a l e d + 0 . 5 f ∗ s t e e r i n g _ s c a l e d +0.1 f ∗
balance_scaled ;
motor2 = t h r o t t l e _ s c a l e d − 0 . 5 f ∗ s t e e r i n g _ s c a l e d − 0.1 f ∗
balance_scaled ;
static
float
float
float
2 Jeder
Usercode abschnitt in der User_Code.pde Datei wird nur kompiliert wenn in der APM_Cong.h Datei
es gewählt wurde.
3 die Flugmotoren werden Automatisch von Der Motor-Matrix Balanciert
30
8. Hardware
8.1. Material
Die meisten Änderungen an der Drohne wurden in Aluminium gemacht. Ein Paar Teile bestehen
aus Stahl.
Die Drohne wurde etwas verändert, 4 Löcher wurden in zwei der Armen gebohrt. Danach
wurden nur zwei weitere Arme hinzugefügt mit den Motoren und Rädern, und ein drittes Rad
vorne angehängt.
8.2. Aufbau
8.2.1. Drittes Rad
Ein Hartbodenrolle wurde vorne an der Drohne als Stutze xiert. Das Rad kann sich noch
vertikal und horizontal drehen.
Abbildung 8.1.: Hartbodenrollen auf der Drohne
8.2.2.
Konzept : Motorisierte Räder
Zwei Stangen wurden senkrecht zu zwei gegenüberliegenden Armen der Drohne xiert. Räder
wurden direkt auf die Motoren xiert, die an Stangen geschraubt sind. Die Motoren wurden
auf den unteren Teil der Stangen angebracht,nach auÿen schauend.
Nach ein paar Tests (10.3.1) wurde bemerkt, dass die Motoren sich zu schnell drehten. Ein
Paar Berechnungen halfen den Grund zu nden.
Es Handelt sich um 850kv Motoren, also 850rpm per Volt. Sie werden mit bis zu 11,1 Volt
gesteuert. Die Motoren fangen erst ab 5-6 V an, die Räder zu bewegen.
850kv ∗ 11, 1v = M axrpm = 9435rpm
= 157rps
Es gibt relativ viele Probleme, wenn die Räder diese Geschwindigkeit erreichen, die Bemerkbarsten sind die Vibrationen, die dabei entstehen, und die Geschwindigkeit, die dabei theoretisch
31
8. Hardware
Abbildung 8.2.: Rad Auf Motor, xiert and Stange
Abbildung 8.4.: Räder separat montiert
Abbildung 8.3.: Propeller auf Motor montiert
erreicht sein würde. // Auch gäbe es keine Bremse. Die Motoren können vom ESC nur beschleunigt werden. Die Drohne würde nur schwer steuerbar sein. Diese Probleme wurden erst
nach einiger Arbeit erkannt.
Aufgrund von Zeitdruck um Material zu besorgen, wurde dieses Problem nicht behoben. Das
alternative Konzept wurde benutzt.
8.3.
8.3.1.
Konzept : Motorisierte Propeller
Wechsel zu den Propellern
Die vorherigen erklärten Probleme führten dazu, dass der Motorantrieb der Räder verworfen
wurde. Das Konzept von Propellern wurde aufgebaut, da alle Teile zur Verfügung standen.
Diese Änderung an Hardware hatte keine Änderung in der Software zur Folge.
8.3.2. Propeller und Motoren
Die Stangen, die für das vorherige Konzept benutzt worden waren, wurden wieder benutzt. Die
Propeller wurden auf Motoren montiert, jetzt an der Vorderseite der Drohne, am oberen Ende
der Stangen.
8.3.3. Räder
Räder wurden am unteren Ende der Stange xiert, nach auÿen.
32
9. Tests
9.1. Test-Methodik
Nach jeder Implementierung wird getestet, die Test-Bedingungen werden hier beschrieben. Bei
den Tests wurden auch andere Fehler als die gesuchten gefunden. Nach jedem erfolgreichen Test
werden die Fehler identiziert und behoben.
9.2. Fahrmodus
Um den Übergang im neuen Modus zu überprüfen, wird in das APMplanner der aktuelle Modus
überprüft. Wenn der Copter in den neuen Modus wechselt, wird der APMplanner nicht den
Modus erkennen. Der angezeigte Modus sollte " Undened " zurück geben. Es soll auch möglich
sein, den Modus zu wechseln, und in dieser Modus die Motoren scharf zu machen. Dies wird
auch im APMplanner angezeigt. Der Fahrmodus sollte nicht aktiviert werden, wenn die Drohne
iegt.
9.3. Fahrimplementierung
Die Fahrimplementierung wird auf mehrere Faktoren überprüft. Zuerst sollen die beiden Motoren durch die Fernsteuerung gesteuert werden. Dabei wird beobachtet, dass die Motoren in
Stärke variieren, wenn man die Throttle ändert, und dass die beiden Motoren invertiert auf
die Direktion reagieren. Auch sollen die Fahrtmotoren sich abschalten, wenn die Drohne nicht
scharf ist, oder die Drohne sich in einem anderen Modus bendet als den Fahrtmodus. Die
Flugmotoren sollen sich nicht im Fahrtmodus bewegen. Die Motoren müssen balanciert werden
können.
9.4. Rad- / Propeller-Montage
Die Motoren sollen sich bewegen, mit den Rädern. Der Joystick der Fernbedienung soll sich
möglichst genau auf die Drehzahl der Motoren auswirken. Die Drohne soll nicht zu stark vibrieren, und die Räder sollen nicht um ein zehnfaches zu schnell drehen.
33
10. Ergebnisse
10.1. Fahrmodus
10.1.1. Wechseln zu dem neuen Modus
Der Fahrtmodus wurde erfolgreich betreten.
Dabei wurden folgenden Mängel bemerkt : Ein wert wurde verwechselt in der ightmode.pde
Datei.
10.1.2. Modi wechseln
Die Drohne kann den Modus verlassen.
Keine Fehler wurden dabei bemerkt.
10.1.3. Motoren Scharf Machen
Die Drohne kann im Fahrtmodus die Motoren Scharf machen, und auch entschärfen.
10.1.4. Flugsicherung
Tests mit reellem Flug waren nicht möglich, da die Drohne nach Modikationen mehr als 2
kg wiegt. Das maximale Abhebegewicht mit 6 Motoren ist laut Vertreiber 3190 Gramm
(BUILD YOUR OWN drone). Da ein Drittel der Motoren nicht mehr zum Flug dienen, wäre
das maximale Abhebegewicht bei ungefähr 2 kg.
Die benutzte Methode, um das Landen zu überprüfen ,wird aber bereits in mehren Teilen des
arducopter code benutzt.
10.2. Fahrimplementierung
10.2.1. Motor-Matrix-Implementierung
Steuerung beider Motoren
Die Drohne konnte mit dieser Implementierung die beiden Motoren steuern, aber einen Starker
Unterschied der Drehzahlen war für beide Motoren bemerkbar.
Abbildung 10.1.: Drohne in Guided Modus
Abbildung 10.2.: Drohne in Fahrtmodus
Abbildung 10.3.: Modus Wechsel Test
35
10. Ergebnisse
Abbildung 10.4.: Drohne im Modus
Abbildung 10.5.: Modus Verlassen
Abbildung 10.6.: Modus Verlassen Test
Abbildung 10.7.: Motoren Nicht Scharf
Abbildung 10.8.: Motoren Scharf
Abbildung 10.9.: Shärfen der Motoren
Einige Fehler wurden bei diesen Tests korrigiert, hauptsächlich wurden Magic Numbers 4 entfernt oder erklärt.
Abschalten der Motoren
Die Motoren wurden abgeschaltet, sobald die Drohne den Modi verlieÿ, allerdings wurden ein
paar Magic Numbers gefunden, die Probleme bereiteten. Dies wurde korrigiert.
Flugmotoren Abschalten
Nicht implementiert.
10.2.2. Balance
Die Motor-Balance wurde implementiert, und getestet.
Einige Phänomene konnten dabei nicht erklärt werden, die nicht am Code lagen sondern an der
Konguration der Drohne.
Die Balance funktionierte.
10.2.3. RC Channel Implementierung
Steuerung beider Motoren
Die Steuerung der beiden Motoren funktioniert. Bei den Tests wurden einige Eigenschaften der
RC_channel Bibliothek bemerkt, die Fehler verursachten. Dies wurde behoben.
Abschalten der Motoren
Das Abschalten der Motoren funktioniert. Keine Probleme bemerkt.
Flugmotoren Abschalten
Das Abschalten der Flugmotoren wurde getestet, die Motoren bewegten sich noch nach dem
Wechsel zu einem anderen Modus. Nach Untersuchung lag der Fehler am Code für das Abschalten der Motoren, zwar wurden neue Werte gegeben, diese wurden aber nicht gesendet.
Das Problem wurde behoben, es gab keinen weitere Probleme.
4 Magic
Number ist eine Zahl im Programmcode, die nicht erklärt wird. Dies sorgt für Verwirrung und macht
es härter, den Code zu lesen und Fehler zu nden.
36
10.3. Hardware-Tests
10.2.4. Balance
Die Balance wurde implementiert, einige Probleme lagen an der Parametrierung der Motoren.
Die Drohne wurde nachdem richtig konguriert, es lief ohne Probleme.
Vermutung liegt, dass die Motor-Matrix-Implementierungsprobleme auch daran lagen.
10.3. Hardware-Tests
10.3.1. Räder mit Motorantrieb
Das Gesamtsystem wurde nur im Stehen geprüft. Nach Rad-Montage (auf die Motoren) wurden
diese getestet. Sehr schnell wurde klar, dass es nicht steuerbar war. Die Vibrationen, die bei diesen Tests vorkamen, reichten aus, um einige Schrauben zu entschrauben. Auch das Kautschuk
eines der beiden Reifen og weg. Die Räder drehten sich erst um ein Zehnfaches zu schnell oder
gar nicht.
Nach diesen Tests wurde das das andere Design gewählt, da die Propeller viel weniger Vibrationen erzeugen.
Abbildung 10.10.: Schraube komplett entschraubt und weggefallen, Mutter im Hintergrund
10.3.2. Propeller mit Motoren
Dieser Gesamtsystem-Test erlaubte es, einige Fehler zu nden. Am Anfang war die Drohne
nicht zu steuern. Auch verlierte sie einen Propeller (gefährlich) und ein Rad. Der Schub der
beiden Motoren war nicht gleich.
Die folgenden Korrekturen wurden wegen dieses Tests gemacht :
* Räder und insbesondere Propeller besser befestigen.
* Minimale und maximale Motorwerte überprüfen. (im ApmMissionplanner2)
* Steuerung etwas weicher für die Drehung gestalten. (Code Änderung)
Nach den Korrekturen ist die Drohne um einiges steuerbarer. Die Drohne hängt noch am
Start wegen der Räder, die zu viel Prol in der Fahrtrichtung haben. Nach einem solchen Start
ist die Drohne nur schwer steuerbar.
37
11. Reexion
Ich habe während dieses Projektes viel gelernt, insbesondere wie man in einem so groÿen Code
wie von Arducopter arbeitet. Ich habe sehr oft gespürt, wie oft und schnell man Zeit im Projektumfeld verliert, besonders wenn etwas nicht genau dokumentiert ist.
Auch habe ich gelernt dass ich jede mögliche Alternative genau anschauen sollte, bevor ich
sie verwerfe. So habe ich viel Zeit verloren, Funktionen zu re-implementieren, die bereits in
einer der Bibliotheken implementiert waren. Die Lösung für die Fahrt-Implementierung, die als
einfachere der beiden Möglichkeit erschien, erwies sich als die schwierigste der beiden.
Es war auch eine lehrreiche Abwechslung, als ich die Mechanik für die Fahrt der Drohne
vorbereitet habe.
Sehr interessant für ein nächstes Projekt wäre es, die Punkt-zu-Punkt-Navigation in einen
Fahrmodus zu implementieren. Auch könnte man die übliche Steuerung eines ferngesteuerten
Autos implementieren und einbauen. Die Bibliothek von den RC_Channel könnte für eine
einfachere Benutzung in der Zukunft aufgeräumt werden. Die Drohne könnte auch erleichtert
werden, damit sie wieder iegen kann.
39
12. Ehrlichkeitserklärung
Mit der Unterschrift bestätigt der Unterzeichnende, dass das Dokument selber geschrieben worden ist und alle Quellen sauber deklariert wurden.
Projektmitglied :
Ort , Datum :
41
Literaturverzeichnis
[1] Arducopter.
4448485.jpg.
Aufbau.
https://www.arducopter.co.uk/uploads/6/7/0/2/6702064/
[2] Wikiedia. Spirallen model. https://commons.wikimedia.org/wiki/File:Spiralmodel_
nach_Boehm.png.
43
A. Codequelle
Das Originalcode-Verzeichnis ist auf github:
https://github.com/diydrohnes/arduipilot
Davon wurde die Version 3.2.1 (eine Branch ) verwendet, da ab Version 3.3 die Firmware zu
groÿ wird für den Controller. Mit den git clone wurde der Sourcecode code heruntergeladen
und mit einen git checkout wurde die richtige Version geladen.
1 git init
2 g i t c l o n e g i t : / / github . com/ d i y d r o n e s / a r d u i p i l o t . g i t
3 g i t checkout ArduCopter − 3.2.1
Der Geänderte Code bendet sich auf github. https://github.com/tqbs/ardupilot/tree/
drive/ArduCopter
45
B. IDE
Als IDE wurde make on linux benutzt. Installiert wurde sie wie auf der Website beschrieben :
http://ardupilot.org/dev/docs/building-the-code-onlinux.html#building-the-code-onlinux
Der Code kann danach von jeden Text Editor geändert werden, und wird im Terminal kompiliert.
1 cd ArduCopter
2 make apm2−quad
3 make upload
Zum schnellen Testen kann auch der Befehl gekürzt werden :
1 make apm2−quad upload
Sehr oft gebrauchter Befehl um Text zu nden :
1 grep − r −e " e x p r e s s i o n " ∗
47
C. Nützliche Informationen
C.1. Fernsteuerung Mapping
Abbildung C.1.: Bild von der Fernsteurung
Mapping :
1. Throttle ( Y-axis )
2. Yaw
3. Roll (X-axis)
4. Pitch
5. Modus Auswahl (3 Möglichkeiten)
6. additionaler Drehknopf, kann zur Kalibrierung benutzt werden
C.2. Bedienung von Ladegerät X80 imaxRC
In diesem Projekt wurde einen imaxRC X80 als Ladegerät benutzt. Die Bedienungsanleitung
fehlte, und war auch nicht online aundbar.
1. Stromquelle einstecken (230V / 12V )
2. Akku einstecken (beide Stecker bei LIPO, Adapter eventuell notwendig)
3. Akku Typ auswählen , Start kurz drucken
4. mit Start (kurz ) zwischen Intensität und Spannung wechseln, den Wert mit inc /dec
ändern.
5. 3 Sekunden lang auf Start drücken, Ladung startet. Fehlermeldungen können hier erscheinen (z.B. Low Voltage )
6. danach nochmal Start drücken, die Ladung sollte jetzt starten.
49
C. Nützliche Informationen
C.3.
APMplanner Bedienung und Installation
C.3.1. Installation
Installation unter Linux mint 17.3, Cinamon. Je nach Linux-Version können verschiedene Probleme bei der Installation vorkommen
1. APM2 Herunterladen
wget http : / / firmware . a r d u p i l o t . org / Tools /APMPlanner/apm_planner_2 . 0 . 1 4 _d
2. Verschiedene Libs installieren, die benötigt werden :
l i b a s o u n d 2 (>= 1 . 0 . 1 6 ) , l i b c 6 (>= 2 . 2 . 5 ) , l i b f l i t e 1 , l i b g c c 1 (>=
1 : 4 . 1 . 1 ) , l i b g l 1 −mesa−g l x | l i b g l 1 , li bopen scen egrap h80 ,
l i b o p e n t h r e a d s 1 4 , libphonon4 (>= 4 : 4 . 2 . 0 ) , l i b q t 4 − d e c l a r a t i v e
(>= 4 : 4 . 7 . 0 ~ rc1 ) , l i b q t 4 −network (>= 4 : 4 . 6 . 1 ) , l i b q t 4 −opengl
(>= 4 : 4 . 5 . 3 ) , l i b q t 4 − s c r i p t (>= 4 : 4 . 5 . 3 ) , l i b q t 4 − s q l (>=
4 : 4 . 5 . 3 ) , l i b q t 4 −svg (>= 4 : 4 . 5 . 3 ) , l i b q t 4 − t e s t (>= 4 : 4 . 5 . 3 ) ,
l i b q t 4 −xml (>= 4 : 4 . 5 . 3 ) , l i b q t c o r e 4 (>= 4 : 4 . 8 . 0 ) , l i b q t g u i 4
(>= 4 : 4 . 8 . 0 ) , l i b q t w e b k i t 4 (>= 2 . 1 . 0 ~ 2 0 1 1 week13 ) , l i b s d l 1 . 2
debian (>= 1 . 2 . 1 1 ) , l i b s n d f i l e 1 (>= 1 . 0 . 2 0 ) , l i b s s l 1 . 0 . 0 (>=
1 . 0 . 0 ) , l i b s t d c++6 (>= 4 . 4 . 0 ) , l i b u d e v 0 (>= 0 . 1 4 0 ) , z l i b 1 g
(>= 1 : 1 . 1 . 4 )
Manche sind nicht in der Version verfügbar, die gebraucht wird. Die neuere Version (oft
+ 1 ) sollte installiert werden.
3. Virtuelle Links für die Libs erstellen, die nicht in der benötigten Version installierbar sind.
1
sudo l n − s / usr / l i b / l i b o s g Q t . so . 9 9 / usr / l i b / l i b o s g Q t . so
.80
2
sudo l n − s / usr / l i b / l i b o s g . so . 9 9 / usr / l i b / l i b o s g . so . 8 0
3
sudo l n − s / usr / l i b / l i b o s g V i e w e r . so . 9 9 / usr / l i b /
l i b o s g V i e w e r . so . 8 0
4
sudo l n − s / usr / l i b / libosgGA . so . 9 9 / usr / l i b / libosgGA . so
.80
5
sudo l n − s / usr / l i b / libosgDB . so . 9 9 / usr / l i b / libosgDB . so
.80
6
sudo l n − s / usr / l i b / l i b o s g T e x t . so . 9 9 / usr / l i b / l i b o s g T e x t
. so . 8 0
7
sudo l n − s / l i b / i386 −linux −gnu/ l i b u d e v . so . 1 / usr / l i b /
l i b u d e v . so . 0
4. APM2 Installieren
1 sudo dpkg − i apm_planner_2 . 0 . 1 4 _debian64 . deb
Ein paar Fehler werden erscheinen, die sind aber kein Problem. Die Installation erfolgt
dennoch.
Wichtig : um andere Pakete zu installieren, muss APM2 wieder entfernt werden :
1 sudo apt −ge t i n s t a l l − f
50
C.3. APMplanner Bedienung und Installation
C.3.2. Bedienung
Um das Programm zu starten :
apmplannner2
51
D. Pichtenheft für Bachelorthesis
53
Selbstgesteurte Drohne mit Räder
Projekt 6 - Pflichtenheft
Autor: Tobias Bernot
Auftraggeber : Nouri T. Prof. Dr. Dip. Eng. Elec./Phys
Betreuer : Nouri T. Prof. Dr. Dip. Eng. Elec./Phys
Experte : Mauricio Reyes Prof. Dr.
Semester : Frühling 16
Fassung: V1.01
1
Inhaltsverzeichnis
1 Einleitung
3
2 Ziele
2.1 Muss-Ziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Wunsch-Ziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Nicht-Ziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
4
4
4
3 Projektumfeld
3.1 Software . . . . . . . . . . . . .
3.1.1 APM 2 . . . . . . . . .
3.1.2 Ardupilot . . . . . . . .
3.2 Hardware . . . . . . . . . . . .
3.2.1 Vorhandene Drohne . .
3.2.2 Erweiterung der Drohne
5
5
5
5
5
5
6
4 Aufgabenliste und Zeitplan
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
7
2
Kapitel 1
Einleitung
Drohnen werden immer häufiger als Lösung für schnelle Lieferungen in schwer
erreichbare Gebiete erwägt. Leider wird dabei einen groen Problem sehr oft vergessen, es kostet relativ viel Energie eine Drohne in die Luft zu halten.
Eine energieeffiziente Lösung wäre der Grund Transport aber der braucht eine
aufgeräumte Umgebung.
Fliegende Drohnen mit Räder könnten effizienter transportieren, und gleichzeitig fähig sein über Behinderungen hinwegzufliegen.
Dieses Projekt beschäftigt sich mit der Erweiterung von einer bestehenden fliegenden Drohne, damit diese auch fahren kann.
Dieses Projekt ist die folge vom den Vorherigen P5. Es werden auch ziele behandelt werden die in den vorherigen Projekt nicht erfüllt wurden.
3
Kapitel 2
Ziele
Dieses Projekt hat drei Kategorien von zielen : Muss-Ziele, Wunsch-Ziele und
Nicht Ziele
2.1
Muss-Ziele
* Fertige Implementierung vom Fahrmodus in der Firmware
* Fahrmodus Integration im APM
* Bestimmung, Bestellung und Ewinbau von notwendigen Mechanischen
Teile für die Fahrt
* Dokumentation, Poster, Website
Fahrmodus Integration im APM
Das APM ermöglicht das planen von benutzen Von Fahrmodi je nach Etappe,
und sollte deshalb auch die Möglichkeit haben die Drohne fahren zu lassen.
Testplanung, Testdurchführung, Testauswertung
Nach jeden Zufügen von neuen Material zur Drohne, sei es eine Implementierung
oder Hardware, wird diese getestet.
2.2
Wunsch-Ziele
2.3
Nicht-Ziele
* Aufbau einer Drohne, eine ist bereits zur Verfügung gestellt.
* Komplette Software für die Drohne entwickeln, einen Open-source Projekt
wird erweitert.
* Komplette Software für die Konfiguration von der Drohne entwickeln,
einen Open-source Projekt wird erweitert.
4
Kapitel 3
Projektumfeld
3.1
3.1.1
Software
APM 2
Das APM Planner 2 Programm kann dazu benutzt werden als Grundstation für
die Drohnen zu dienen. Es ist Opensource Software und kann deshalb beliebig
erweitert werden. Bislang ermöglicht ist :
* Erstellung, Modifizierung von Flugplänen
* Das Lesen von Sensordaten
* Das Testen von Motoren
* Das Loggen von Daten
* Die (Erst)Konfiguration von Drohnen
3.1.2
Ardupilot
Die Ardupilot Software ist einen Opensource Programm zur Steuerung von
Drohnen. In dieses Projekt werden die Komponenten Ardu-Copter benutzt die
darauf gerichtet sind Drohnen zu steuern
Das Ardu-copter soll so erweitert werden das die Drohne eine Fahrmodus
bekommt.
3.2
3.2.1
Hardware
Vorhandene Drohne
Eine Drohne wird für das Projekt zur Verfügung gestellt. Es Handerle sich um
einen Quadrophonie in H-Konfiguration. Es gibt einen APM 2 als Mikrocontroller an Bord. (Funktioniert so wie eine Arduino Mega 2560)
5
3.2.2
Erweiterung der Drohne
Die Drohne wird mit drei Räder erweitert, zwei davon motorisiert. Halterungen
dafür sollen installiert werden.
6
Kapitel 4
Aufgabenliste und Zeitplan
Als Datum für die Termine mit den Experten gelten : Nach der Planung, nach
den 2-3 ersten Implementierungen und nach allen Implementierungen.
7
Proj_6
Tasks
Mar 8, 2016
2
Name
Planung
Pflichtenheft
Mechaniches Desing
Testplanung
Software Desing Farhinteface
Software Desing APM Fahrmodus
Begin date
2/22/16
2/22/16
3/7/16
3/7/16
3/7/16
3/7/16
End date
3/19/16
3/3/16
3/19/16
3/19/16
3/19/16
3/19/16
Implementierung
Firmware
Fahrinterface
Farhmodus
APM
Fahrmodus
Einbau Motoren & Mechanik
3/21/16
3/21/16
3/21/16
4/11/16
5/2/16
5/2/16
5/23/16
6/4/16
4/23/16
4/2/16
4/23/16
5/14/16
5/14/16
6/4/16
Test und Fehler korrektur
Firmware Fahrinterface
Firmaware Fahrmodus
APM Fahrmodus
Einbau Motoren
4/4/16
4/4/16
4/25/16
5/16/16
6/6/16
6/11/16
4/9/16
4/30/16
5/21/16
6/11/16
Dokumentation
Thesis
Website
Präsentation
3/31/16
3/31/16
6/13/16
6/20/16
6/30/16
6/18/16
6/23/16
6/30/16
Treffen Mit Experten 1
Treffen Mit Experten 2
Treffen Mit Experten 3
3/21/16
5/2/16
6/13/16
3/21/16
5/2/16
6/13/16
Begin date
End date
5/2/16
5/16/16
6/6/16
APM Fahrmodus
Einbau Motoren
5/2/16
6/13/16
Treffen Mit Experten 2
Treffen Mit Experten 3
6/20/16
Präsentation
3/21/16
6/13/16
Website
Treffen Mit Experten 1
3/31/16
Thesis
3/31/16
4/25/16
Firmaware Fahrmodus
Dokumentation
4/4/16
4/4/16
Firmware Fahrinterface
Test und Fehler korrektur
Einbau Motoren & Mechanik 5/23/16
Fahrmodus
5/2/16
4/11/16
Farhmodus
APM
3/21/16
Fahrinterface
3/21/16
Firmware
3/19/16
Software Desing APM Fahr... 3/7/16
3/21/16
3/19/16
Software Desing Farhintefa... 3/7/16
Implementierung
3/19/16
3/7/16
6/13/16
5/2/16
3/21/16
6/30/16
6/23/16
6/18/16
6/30/16
6/11/16
5/21/16
4/30/16
4/9/16
6/11/16
6/4/16
5/14/16
5/14/16
4/23/16
4/2/16
4/23/16
6/4/16
3/19/16
3/7/16
Testplanung
3/3/16
3/19/16
Mechaniches Desing
2/22/16
2/22/16
Name
Pflichtenheft
Planung
Proj_6
Gantt Chart
Week 11
3/6/16
2/28/16
2016
Week 10
3/13/16
Week 12
3/20/16
Week 13
3/27/16
Week 14
4/3/16
Week 15
4/10/16
Week 16
4/17/16
Week 17
4/24/16
Week 18
5/1/16
Week 19
5/8/16
Week 20
5/15/16
Week 21
5/22/16
Week 22
5/29/16
Week 23
6/5/16
Week 24
6/12/16
Week 25
6/19/16
Week 26
6/26/16
Week 27
7/3/16
Week 28
7/10/16
Week 29
7/17/16
Week 30
7/24/16
Week 31
7/31/16
Week 32
8/7/16
Week 33
8/14/16
Week 34
8/21/16
Week 35
8/28/16
Week 36
9/4/16
Week 37
3
Mar 8, 2016
9/11/16
Week 38
Abbildungsverzeichnis
2.1.
2.2.
2.3.
2.4.
apm2 . . . . . . . . . . . . . . . . . . . . . . . .
Struktur der Drohne [1] . . . . . . . . . . . . .
APM Logo, für die Ardupilot Software. . . . . .
APMplaner2, Flight data Ansicht, in Windows.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
11
11
12
12
5.1. Zeitplan , ( Datum in US Schreibweise) . . . . . . . . . . . . . . . . . . . . . . 17
5.2. Spiralen Model nach Boem [2] . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.1. Wechseln der Parameter in Apmplanner2
. . . . . . . . . . . . . . . . . . . . . 23
7.1. Abweichung vom Standard verlauf mit zugri auf RC_channel . . . . . . . . . . 25
7.2. Abweichung vom Standard verlauf mit zugri auf Motor_Matrix . . . . . . . . . 26
8.1.
8.2.
8.3.
8.4.
Hartbodenrollen auf der Drohne . .
Rad Auf Motor, xiert and Stange
Propeller auf Motor montiert . . .
Räder separat montiert . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
31
32
32
32
10.1. Drohne in Guided Modus . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.2. Drohne in Fahrtmodus . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3. Modus Wechsel Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4. Drohne im Modus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.5. Modus Verlassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.6. Modus Verlassen Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.7. Motoren Nicht Scharf . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.8. Motoren Scharf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.9. Shärfen der Motoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.10.Schraube komplett entschraubt und weggefallen, Mutter im Hintergrund
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
35
35
35
36
36
36
36
36
36
37
C.1. Bild von der Fernsteurung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
63

Download Report