Projekt 75: UWB Ortung

Autor: Stephan Marks, Klaus Schmidt

Betreuer: Prof. Schneider

Aufgabe

Aufbau eines UWB-Ortungssystems (z.B. Posyx-Shield)

Erwartungen an die Projektlösung

Recherche zu UWB-Positionierung
Auswahl eines UWB Systems
Beschaffung eines UWB-Systems
Messaufbau
Inbetriebnahme
Validierung der Güte mit dem TopCon Lasertracker-System
Machen Sie spektakuläre Videos, welche die Funktion visualisieren.
Test und wiss. Dokumentation
Live Vorführung während der Abschlusspräsentation

Schwierigkeitsgrad

Mittel (***)

Einleitung

Im Studiengang Mechatronik der Fachhochschule Hamm-Lippstadt wird im fünften Semester das Elektrotechnik-Fachpraktikum durchgeführt. Dies zählt zum Modul Mechatronische Systeme II und dient der Vertiefung der angewandten Elektrotechnik. In dem Praktikum werden zusätzlich zu verschiedenen Versuchen einzelne Projekte in den Bereichen Elektrotechnik und Regelungstechnik in Kleingruppen bearbeitet. Dieser Artikel dient der Projektdokumentation des Projekts 75 UWB-Ortung, dem Festhalten von Ergebnissen sowie der Interessensweckung für die Verwendung eines UWB-Ortungssystems.

Einführung

Die Abkürzung UWB steht für Ultra-Wideband (deutsch: Ultrabreitband). Ein großer Vorteil dieser Technologie ist ihre hohe Übertragungssicherheit. Ein weiterer Vorteil dieser Technologie ist, dass das Nutzungssignal nur schwer erkenn- und ortbar ist, da die spektrale Leistungsdichte unterhalb des thermischen Rauschens gehalten wird. Somit ist es ideal für den militärischen Einsatz geeignet. Mit einer Bandbreite von mindestens 500 MHz der Mittenfrequenz werden in der UWB-Ortung extrem große Frequenzbereiche (3,1 GHz bis 10,6 GHz) genutzt. Dadurch eröffnet sich eine Vielzahl von Anwendungsmöglichkeiten. Bei der UWB-Ortung wird die Information durch eine definierte Folge kurzer gaußförmiger Impulse übertragen. Hierdurch erhält das Signal die gewünschte hohe Bandbreite und die übertragene Leistung verteilt sich auf einen großen spektralen Bereich. ^[1]

Die Positionsbestimmung wird nach dem Laufzeitverfahren (Time of Flight, ToF) durchgeführt. Dabei wird die Übertragungsdauer zwischen dem Senden und Empfangen von Signalen ermittelt.^[2] Zudem können durch ein so genanntes Impulsradio-Verfahren mit Pulsphasenmodulation Daten übertragen werden.^[3]

Das in diesem Projekt verwendete Pozyx-System ist eine Hardwarelösung, die genaue Informationen zur Positionierung und Bewegung liefert. Das System besteht aus fünf Modulen, davon vier Anker, welche die Sender des Systems darstellen und einem Tag als Empfänger. Um eine Positioniergenauigkeit von wenigen Zentimetern zu erreichen, setzt das pozyx-System auf eine neuartige drahtlose Funktechnologie namens Ultra-Wideband (UWB). Die mit dieser Ultra-Breitband-Technologie erreichte Genauigkeit ist um ein Vielfaches besser als bei herkömmlichen Positionierungssystemen, die auf WiFi, Bluetooth, RFID oder GPS-Signalen basieren. Darüber hinaus können die Signale Wände durchdringen und sie für Innenräume geeignet machen.

Einige Anwendungsmöglichkeiten, die mit dem Pozyx-System realisiert werden können:

Navigation von Robotern und Drohnen
Entfernungsmessung durch Wände
Zuordnung von Montagewerkzeugen in der Automobilindustrie^[4]

Verwendete Bauteile

Pos.:	Bezeichnung:	Anzahl in Stk. sonst angegeben:
1.	UWB-Ortungssystem: Pozyx Ready to Localize	1
2.	Holzgrundplatte	1
3.	Holzbalken	4
4.	Montagewinkel	8
5.	Holzschraube	44
6.	Klebeband	1 m
7.	Steckdosenleiste 6fach	1
8.	Arduino Uno Rev. 3	1
9.	Arduino Breadboard	1
10.	Arduino Verbindungskabel	1 Packung
11.	Powerbank	1
12.	Bluetoothmodul HC-05	1
13.	USB A-B-Kabel	1
14.	Widerstand 1,2kΩ	1
15.	Widerstand 2,2kΩ	1

Projekt

Projektplan

Für das Projekt UWB-Ortung wird in Hinblick auf eine Livevorführung an einem Messestand ein kompakter Testaufbau erstellt. An diesem soll das Funktionsprinzip der Ultrabreitband-Ortung veranschaulicht werden. Des Weiteren sollen die räumlichen Positionskoordinaten der Ortung in Form eines dreidimensionalen MATLAB-Plots visualisiert werden. Um eine praktikable Datenübertragung zu realisieren, ähnlich einer praktischen Anwendung wie beispielsweise die Ortung eines autonomen Roboters, wird die kabellose Datenübertragung per Bluetooth gewählt.

Projektziele

Erstellen eines Testaufbaus zur Vorführung der UWB-Ortung in Form eines Messestands
Inbetriebnahme des UWB-Ortungssystems
Empfangen von dreidimensionalen Positionsdaten
Implementierung eines Arduino-Sketches zur UWB-Ortung mittels Arduino-Shield
Kabellose Datenübertragung per Bluetooth unter Verwendung des HC-05-Bluetoothmoduls
Implementierung eines MATLAB-Skripts zur räumlichen Visualisierung der Positionskoordinaten
Validierung der Ortungsgenauigkeit
Dokumentation des Projekts

Projektdurchführung

Für das Projekt wird das Ready to Localize Tutorial von Pozyx in angepasster Form verwendet. Im nachfolgenden Abschnitt wird dieses Tutorial näher erläutert. In dem Programm wird die Positionierung mit dem System durchgeführt. Zuerst werden die Ankerpositionen eingerichtet, um anschließend eine Positionierung durchzuführen können. Danach werden die Positionsdaten des Pozyx relativ zum Ankeraufbau empfangen.

Anker Setup und Messung

Das Pozyx-Positionierungssystem erfordert, dass die vier Anker in einem Bereich platziert werden, in dem positioniert werden möchte. Einige wichtige Regeln zur Ankerplatzierung werden im Folgenden gezeigt:

Die Anker müssen mit dem Antennenchip nach oben befestigt werden und in der Sichtlinie des Benutzers aufgebaut werden.
Die Anker müssen um den Benutzer verteilt werden und dürfen nicht auf einer Linie verteilt werden.
Für die 3D-Positionierung, die in diesem Projekt verwendet wird gilt, dass die Anker auf verschiedenen Höhen platziert werden müssen.

Bevor die Anker positioniert werden, ist es sinnvoll eine Skizze mit den Positionen und den Adressen der Anker anzufertigen. Die Adresse der Anker befindet sich als Hexadezimalzahl auf einem Etikett der Anker. In der nachfolgend Abbildung „Positionierung der Anker“ werden nun die Positionen der Anker dargestellt.

Vom Hersteller selber wird eine manuelle Kalibrierung zur Messung vorgeschlagen, da sie genauer ist als die automatische Kalibrierung. Für das Projekt wurden nun die Anker mit einem Zollstock ausgemessen.

Das Koordinatensystem

Ausgehend von der Abbildung „Positionierung der Anker“, wird nun ein Koordinatensystem erzeugt, um die Koordinaten der Anker zu bestimmen. Die Nachfolgende "Das Koordinatensystem" beschreibt nun diese Darstellung.

Ausgehend von dem Koordinatensystem bildet der Anker mit der Adresse 0x6926 den Ursprung des Koordinatensystems. Des Weiteren bilden die Anker 0x6926 und 0x690E die x-Achse. Auf der y-Achse befindet sich der Anker mit der Adresse 0x6932. Nun werden die Anker mit einem Zollstock vermessen. Zu beachten ist, dass ausgehend von der Mitte der Antenne des Ankers die Position bestimmt wird. Auf das Projekt bezogen ergibt sich folgende Tabelle mit den Positionsdaten der Anker in Millimeter:

Adresse	x-Koordinate	y-Koordinate	z-Koordinate
0x6926	0	0	760
0x6932	0	838	992
0x696B	1221	830	555
0x690E	1221	0	145

Im nachfolgend wird nun der Programm Code erläutert. Der Code wurde in einem Sketch in der Arduino Software geschrieben. In diesem ersten Abschnitt wurden nun die Koordinaten der Ankers eingefügt. Des Weiteren wurde die Bluetooth Schnittstelle eingebunden, um später die Koordinaten drahtlos zu empfangen.

Arduino Sketch

Eine Beschreibung des Programms kann aus [1] entnommen werden.

#include "Pozyx.h"
#include "Pozyx_definitions.h"
#include "Wire.h"
#include "SoftwareSerial.h"

////////////////////////////////////////////////
////////////////// PARAMETERS //////////////////
////////////////////////////////////////////////

uint16_t remote_id = 0x6000;                            // set this to the ID of the remote device
bool remote = false;                                    // set this to true to use the remote ID

boolean use_processing = false;                         // set this to true to output data for the processing sketch

const uint8_t num_anchors = 4;                              // the number of anchors
uint16_t  anchors[4] = {0x6926, 0x690E, 0x6932, 0x696B};    // the network id of the anchors: change these to the network ids of your anchors.
int32_t anchors_x[4] = {0, 1221, 0, 1221};                  // anchor x-coorindates in mm
int32_t anchors_y[4] = {0, 0, 838, 830};                    // anchor y-coordinates in mm
int32_t heights[4] =   {760, 145, 992, 555};                // anchor z-coordinates in mm

uint8_t algorithm = POZYX_POS_ALG_UWB_ONLY;             // positioning algorithm to use. try POZYX_POS_ALG_TRACKING for fast moving objects.
uint8_t dimension = POZYX_3D;                           // positioning dimension
int32_t height = 0;                                     // height of device, required in 2.5D positioning

// SoftwareSerial für Bluetooth
SoftwareSerial BluetoothSerial(10, 11); // RX, TX


////////////////////////////////////////////////

void setup(){
  Serial.begin(115200);
  BluetoothSerial.begin(9600);

  if(Pozyx.begin() == POZYX_FAILURE){
    Serial.println(F("ERROR: Unable to connect to POZYX shield"));
    Serial.println(F("Reset required"));
    delay(1000);
    abort();
  }

 int status = Pozyx.doDiscovery();

  if(!remote){
    remote_id = NULL;
  }

  // clear all previous devices in the device list
  Pozyx.clearDevices(remote_id);

  // sets the anchor manually
  setAnchorsManual();
  // sets the positioning algorithm
  Pozyx.setPositionAlgorithm(algorithm, dimension, remote_id);

  //printCalibrationResult();
  delay(2000);
}

void loop(){
  coordinates_t position;
  int status;
  if(remote){
    status = Pozyx.doRemotePositioning(remote_id, &position, dimension, height, algorithm);
  }else{
    status = Pozyx.doPositioning(&position, dimension, height, algorithm);
  }

  if (status == POZYX_SUCCESS){
    // prints out the result
    printCoordinates(position);
  }else{
    // prints out the error code
    //printErrorCode("positioning");
  }
}

// prints the coordinates for either humans or for processing
void printCoordinates(coordinates_t coor){
  uint16_t network_id = remote_id;
  if (network_id == NULL){
    network_id = 0;
  }
  if(!use_processing){
    BluetoothSerial.print(coor.x);
    BluetoothSerial.print(",");
    BluetoothSerial.print(coor.y);
    BluetoothSerial.print(",");
    BluetoothSerial.println(coor.z);
  }else{
    Serial.print(coor.x);
    Serial.print(",");
    Serial.print(coor.y);
    Serial.print(",");
    Serial.println(coor.z);
  }
}

// error printing function for debugging
void printErrorCode(String operation){
  uint8_t error_code;
  if (remote_id == NULL){
    Pozyx.getErrorCode(&error_code);
    Serial.print("ERROR");
    Serial.print(operation);
    Serial.print(", local error code: 0x");
    Serial.println(error_code, HEX);
    return;
  }
  int status = Pozyx.getErrorCode(&error_code, remote_id);
  if(status == POZYX_SUCCESS){
    Serial.print("ERROR ");
    Serial.print(operation);
    Serial.print(" on ID 0x");
    Serial.print(remote_id, HEX);
    Serial.print(", error code: 0x");
    Serial.println(error_code, HEX);
  }else{
    Pozyx.getErrorCode(&error_code);
    Serial.print("ERROR ");
    Serial.print(operation);
    Serial.print(", couldn't retrieve remote error code, local error: 0x");
    Serial.println(error_code, HEX);
  }
}

// print out the anchor coordinates (also required for the processing sketch)
void printCalibrationResult(){
  uint8_t list_size;
  int status;

  status = Pozyx.getDeviceListSize(&list_size, remote_id);
  Serial.print("list size: ");
  Serial.println(status*list_size);

  if(list_size == 0){
    printErrorCode("configuration");
    return;
  }

  uint16_t device_ids[list_size];
  status &= Pozyx.getDeviceIds(device_ids, list_size, remote_id);

  Serial.println(F("Calibration result:"));
  Serial.print(F("Anchors found: "));
  Serial.println(list_size);

  coordinates_t anchor_coor;
  for(int i = 0; i < list_size; i++)
  {
    Serial.print("ANCHOR,");
    Serial.print("0x");
    Serial.print(device_ids[i], HEX);
    Serial.print(",");
    Pozyx.getDeviceCoordinates(device_ids[i], &anchor_coor, remote_id);
    Serial.print(anchor_coor.x);
    Serial.print(",");
    Serial.print(anchor_coor.y);
    Serial.print(",");
    Serial.println(anchor_coor.z);
  }
}

// function to manually set the anchor coordinates
void setAnchorsManual(){
  for(int i = 0; i < num_anchors; i++){
    device_coordinates_t anchor;
    anchor.network_id = anchors[i];
    anchor.flag = 0x1;
    anchor.pos.x = anchors_x[i];
    anchor.pos.y = anchors_y[i];
    anchor.pos.z = heights[i];
    Pozyx.addDevice(anchor, remote_id);
  }
  if (num_anchors > 4){
    Pozyx.setSelectionOfAnchors(POZYX_ANCHOR_SEL_AUTO, num_anchors, remote_id);
  }
}

Bluetooth Modul

Im Folgenden wird nun das Bluetooth Modul nähert erläutert. Für das Projekt wird das Bluetooth Modul HC-05, welches kompatibel mit einem Arduino ist, verwendet. Dieses Modul dient dazu, dass die Positionsdaten des Tags drahtlos übertragen werden. In der folgenden Abbildung wird der Verdrahtungsplan des Moduls mit dem Arduino Uno gezeigt.

Matlab Skript

In diesem Abschnitt wird die Schnittstelle zwischen dem Pozyx System und MATLAB zur Visualisierung der Ortungskoordinaten beschrieben. In dem Programm wird zunächst die Bluetoothverbindung zwischen dem Arduino und dem Computer hergestellt, auf dem das MATLAB-Skript ausgeführt wird. Anschließend erfolgt die Initialisierung der Figure, in welcher der dreidimensionale Plot dargestellt wird. In einer Endlosschleife werden die empfangenen Bluetoothdaten verarbeitet. Dazu werden mehrere Koordinaten eingelesen, um einen Durchschnittswert zu berechnen. Dadurch wird eine geringere Streuung der Koordinaten erzielt. Für die Anzahl der zur Berechnung eingelesenen Koordinaten muss ein Kompromiss zwischen geringer Streuung und Geschwindigkeit neuer Plot-Punkte gefunden werden. Zuletzt werden die neuen Koordinaten in einem räumlichen Plot in Form von blauen Punkten visualisiert.

clear all;
close all;
clc;
disp('Startet...');

% Herstellen der Bluetoothverbindung
b = Bluetooth('HC-05',1);
fopen(b);
disp(b);

% Initialisieren der Figure
figure('Name','3D-UWB-Ortung','units','normalized', 'outerposition', [0 0 1 1]);

view(-170,3);

xlim([0, 1225]);
xlabel('x/mm');
ylim([0, 852]);
ylabel('y/mm');
zlim([0,993]);
zlabel('z/mm');
grid on
hold on;

% Variablen
v = zeros(1,3);
anz = 4;

% Datenverarbeitung
while (1)
    
    xSum = 0;
    ySum = 0;
    zSum = 0;
    
    for k = 1:anz
        data = 0;
        data = fgetl(b); % Empfangene Daten auslesen
        v = str2num(data);
        
        if ( ~isempty(v) &&  isequal([1,3], size(v)) )
            xSum = xSum + v(1,1);
            ySum = ySum + v(1,2);
            zSum = zSum + v(1,3);
        end
    end
    
    x = xSum/anz;
    y = ySum/anz;
    z = zSum/anz;
    
 scatter3(x,y,z,'b*') % Visualisierung
 
 pause(0.001);
end

fclose(b);

disp('Beendet...')

Testaufbau

Fertiggestellter Testaufbau
Testaufbau mit Ankerpositionen und Tag
Ankerposition am Balken
Darstellung des Matlab Plots mit dem Tag

Im folgenden Abschnitt wird nun der Testaufbau grafisch dargestellt.Das linke Bild zeigt die Ankerpositionierung und den Tag in der Mitte auf der Grundplatte. Nach den Regeln der Ankerpositionierung, die im Abschnitt 7.3.1 erläutert wurden, werden nun die Anker im folgenden Aufbau in verschiedenen Höhen an den Balken festgeschraubt. Des Weiteren besteht der Tag aus einem Pozyx Shield, dass auf den Arduino gesteckt wurde. Das Bluetooth Modul ist ebenfalls mit dem Shield verbunden, um die Koordinaten drahtlos zu senden. Ausgehend vom Aufbau wird der Tag nun auf der Grundplatte bewegt, die den Raum darstellt. Dieser Raum wird dann in einem Koordinatenkreuz in Matlab geplottet. Das mittlere Bild, zeigt einen Anker von nahen und das rechte Bild verdeutlicht noch mal den Matlab Plot, der auf dem Notebook zusehen ist. Die ungefähren Koordinaten stellen somit die Mitte der Grundplatte grafisch dar.

Ergebnisse und Herausforderungen

MATLB-Plots der Ortungskoordinaten.
Räumliche Darstellung der Ortungskoodinaten in Richtung der xz-Ebene. Gradlinige Bewegung des Empfängers parallel zur xy-Ebene.
Darstellung der Ortungskoordinaten in der yz-Ebene. Gradlinige Bewegung des Empfängers parallel zur xy-Ebene.
Darstellung der Ortungskoordinaten in der xy-Ebene. Kreuzförmige Bewegung des Empfängers entlang der Achsenhalbierenden.

In den obrigen Abbildungen sind mit MATLAB erstellte Plots der Ortungskoordinaten aus verschiedenen Perspektiven dargestellt. Dort ist eine starke Streuung der Koordinaten zu erkennen. Die Koordinaten aus der Betrachtungsrichtung der xz-Ebene (links) stellen eine gradlinige Bewegung des Empfängers parallel zur xy-Ebene dar. Es ist ein Anstieg der z-Kompnente im mittleren Bewegungsbereich erkennbar. Bei der Betrachtung der Koordinaten in der yz-Ebene (mitte) ist ab einem Wert von y = 200 mm eine extreme diagonale Streuung zu beobachten. Beim Blick auf die xy-Ebene (rechts) wurde eine kreuzartige Bewegung druchgeführt. Es ist zu erkennen, dass mittig ein Abfall der y-Komponente stattfindet. Zudem wurden teilweise in den Rangbereichen der Achsen keine Koordinaten bestimmt.

Mögliche Gründer der abweichenden Ortungskoordinaten können zum einen der kompakte Testaufbau sein. Eventuell müssen für eine genauere Ortung die Sender weiter voneinander entfernt angebracht werden. Zum Anderen sollten die Koordinaten der Sender durch eine noch genauere Vermessung ermittelt werden.

Als herausfordernd stellte sich die kabellose Übertragung der Ortungsdaten heraus. Durch eine zunächst irreführende Beschreibung eines sogenannten Remote-Modus durch die Dokumentation des Herstellers Pozyx stellte sich heraus, dass eine kabellose Übertragung der Koordinaten nur durch ein zusätzliches Bluetoothmodul möglich ist. Diese Erkenntnis entstand nach verschiedenen Testansätzen und wurde durch Kontaktaufnahmen mit dem Hersteller bestätigt. So wurde der Empfängeraufbau um ein HC-05-Bluetoothmoduls erweitert. Problematisch war zudem, dass das Pozxy-Empfändershield die einzige serielle Schnittstelle des Aurduino Unos verwendet. Somit konnte das Bluetoothmodul nicht an diese angeschlossen werden. Die Problematik wurde durch das Verwenden der SoftwareSerial-Library gelöst, welche mittels zwei digitalen Ein- beziehungsweise Ausgängen eine weitere serielle Schnittstelle nachbildet.

Projektfortführung

Verbesserung der Genauigkeit
Validierung der verbesserten Genauigkeit
Empfängeraufbau aus den Breadboard als Arduinoshield umsetzen
Plotgeschwindigkeit in MATLAB erhöhen

Zusammenfassung

Zusammenfassend war das Projekt UWB Ortung des GET-Fachpraktikums ein sehr interessantes Projekt, welches auch einige Herausforderungen darstellte. Anfänglich gab es ein paar Schwierigkeiten, da die Bauteile spät geliefert wurden und zum Ende des Semesters wurde es dann noch ein zeitintensives Projekt. Durch das Freie arbeiten in der Projektwerkstatt, konnte nun dieses Projekt zum Ende des Semester erfolgreich abgeschlossen werden. Des Weiteren konnten wir in diesem Projekt, dass theoretische Hintergrundwissen zur Programmierung in Matlab weiter vertiefen und auch praktisch anwenden. Auch einige Steuerungskompetenzen, die im Studium gelehrt wurden, konnten ebenfalls gut vertieft werden.

Quellen

↑ UWB (Ultra Wide Band). Abgerufen am 18. Januar 2018.
↑ Funktionsweise von Indoor Lokalisierung mit Ultra-wideband. Abgerufen am 19. Januar 2018.
↑ Impulsradio. Abgerufen am 19. Januar 2018.
↑ Smartfactory – UWB-Funk-Ortungssysteme in der Automobilproduktion im Einsatz. Abgerufen am 18. Januar 2018.

Weblinks

Posyx-Shield

Projektunterlagen

YouTube Video

Das YouTube Video zu unserem Projekt ist hier zu finden.

→ zurück zum Hauptartikel: WS 17/18: Fachpraktikum Elektrotechnik (MTR)

[1] UWB (Ultra Wide Band). Abgerufen am 18. Januar 2018.

[2] Funktionsweise von Indoor Lokalisierung mit Ultra-wideband. Abgerufen am 19. Januar 2018.

[3] Impulsradio. Abgerufen am 19. Januar 2018.

[4] Smartfactory – UWB-Funk-Ortungssysteme in der Automobilproduktion im Einsatz. Abgerufen am 18. Januar 2018.

[1]

[2]

[3]

[4]