Projekt 75: UWB Ortung

Quelle: https://www.pozyx.io/

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

Das Wort UWB steht für Ultra Wide Brand (dt. Ultra Breitband). 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 digitaler Impulse übertragen. Hierdurch erhält das Signal die gewünschte hohe Bandbreite und die übertragene Leistung verteilt sich auf einen großen spektralen Bereich.

Das pozyx-System ist eine Hardwarelösung, die genaue Informationen zur Positionierung und Bewegung liefert. Das System besteht aus 5 Modulen, davon 4 Anker und ein Tag. 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önen:

• Einen Roboter oder eine Drohne sicher in einem Haus navigieren.
• Jede Entfernung messbar, sogar durch Wände!

Verwendete Bauteile

Pos.:	Bezeichnung:	Anzahl in Stk. sonst angegeben:
1.	HUWB-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 Ultraweitband-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 dieses Projekt wird nun in Anlehnung das Ready to Localize Tutorial von Pozyx verwendet. Im nachfolgenden Abschnitt wird nun dieses Tutorial näher erläutert: In diesem Tutorial wird nun die Positionierung mit dem System durchgeführt. Als erstes werden zuerst die Ankerpositionen eingerichtet, um später eine Positionierung durchzuführen können. Danach werden genaue 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 nun im Folgenden gezeigt:

1. Die Anker müssen mit dem Antennenchip nach oben befestigt werden und in der Sichtlinie des Benutzers aufgebaut werden.
2. Die Anker müssen um den Benutzer verteilt werden und dürfen nicht auf einer Linie verteilt werden.
3. 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 „Abb.1 Positionierung der Anker“ werden nun die Positionen der Anker dargestellt.

Positionierung der Anker

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 Abb.1 „Positionierung der Anker“, wird nun ein Koordinatensystem erzeugt um die Koordinaten der Anker zu bestimmen. Die Nachfolgende Abbildung 2 Das Koordinatensystem beschreibt nun diese Darstellung.

Koordinatensystem

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	758
0x6932	0	838	994
0x696B	1221	830	555
0x690E	1221	0	147

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.

#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);
  }
}

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. Im nachfolgenden wird der Programmcode des Moduls gezeigt, welcher mit der Software Matlab in einem Skript geschrieben wurde.

clear all;

b = Bluetooth('HC-05',1);
%b.Terminator = '$';
fopen(b);
b

%write and read function
%fwrite(b,Bluetooth_Write,'uchar');

while (1)
    data = fgetl(b)
    Bluetooth_Read=str2num(data)
    
    pause(0.1);
end

Als letztes wird nun die Schnittstelle mit dem Pozyx System und Matlab beschrieben. In dem Matlab Skript wurde nun ein 3D-Plot erzeugt, welches die Positionsdaten des Tags grafisch darstellt.

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

b = Bluetooth('HC-05',1);
fopen(b);
disp(b);

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;

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

% line([0,1225], [576,576],'Color','r') % +15cm
% 
% line([0,1225], [476,476],'Color','b')% +5cm
% 
% line([0,1225], [426,426],'Color','g')
% 
% line([0,1225], [376,376],'Color','b') % -5cm
% 
% line([0,1225], [276,276],'Color','r') % -15cm

while (1)
    
    xSum = 0;
    ySum = 0;
    zSum = 0;
    
    for k = 1:anz
        data = 0;
        data = fgetl(b); % Empfangene Daten ausgeben
        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*')
 
 pause(0.001);
end

fclose(b);

disp('Beendet...')

Ergebnisse und Herusforderungen

• 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 geanauere 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 so genannten 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

Weblinks

• Posyx-Shield

YouTube Video

---

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