Navigation in der Wohnung

[Moppi]

Was man manchmal alles so macht - finde ich nicht schlecht!

Ich habe auch mal Programme mit VB geschrieben, war aber glaub noch Version 4. 1995 bis 1997. Man kann mit VB wirklich gut solche Sachen machen. Ich habe dazumal Flughafenkarten in einen Editor geladen, als Bitmap. Dazu ein Algorithmus, um Häuser zu plazieren und zu drehen. Also Häuser für Terminalgebäude etc. So konnte ich also die Größe der Gebäude - nach Kartenvorlage - direkt anpassen und in die richtige Position drehen. Auch die Funkfeuer konnte ich so setzen, da die in den Karten angegeben waren. Auch Baumbewuchs habe ich eintragen können. Nachher sind die Daten exportiert worden, damit Dateien für den MS Flugsimulator erstellt werden konnten. Dafür hatte ich damals eine Software (ich glaub FS Designer hieß die), habe da noch ein wenig drum herum geschrieben, also eine eigene EXE- oder COM-Datei, damit ich den Vorgang automatisch von Anfang bis Ende durchlaufen lassen konnte. Das Original Tool war leider etwas eingeschränkt, ich glaube da waren nur max. 5 oder 10 Häuser möglich paar Landebahnen und Straßen. Bäume habe ich damit selber generiert (zwei Bitmaps im 90 Grad Winkel ineinandergestellt, ich glaube da musste man ein Gebäude als Grundobjekt nehmen und dann die Bitmap auf die Flächen setzen. Je nach Richtungsvektor oder so ähnlich wurden dann nur die Bitmaps dargestellt und die Wände des Gebäudes nicht). Aber der Designer erlaubte das Zusammenführen mehrerer Objektdateien, die man damit generiert hatte. Das habe ich dann ausgenutzt. Aufgrund meiner Erweiterung konnte ich dann also riesige Flächen mit Häusern per Zufallsgenerator bebauen, wie Berlin z.B.. Das war damals noch Seltenheit im MS Flugsimulator. Meist gab es ja nur ein paar Flughafengebäude bzw. mal ein markantes Gebäude in einer Stadt und das war es dann so weit. Bloß leider kann ich die alte VB Version nicht mehr installieren, so dass ich auch auf meine Programme nicht mehr zugreifen kann, die ich damit geschrieben habe.

Von daher weiß ich, was Du geleistet hast und finde das toll!
Schade ist aber, dass Du mit der Browser-Schnittstelle nicht weiter kommst!


MfG



PS:

Einmal habe ich Paderborn nachgebaut, das sah dann für den FS Designer z.B. so aus:

'******************************************************************** 
ID 1                            'Szenerie-ID
'********************************************************************
'--------------------------------------------------------------------
'Szenerie beschreiben
'--------------------------------------------------------------------
 GEO_AREA "GERMANY"


'--------------------------------------------------------------------
'Ausmaáe der Szenerie
'--------------------------------------------------------------------
include "range1.inc"


'********************************************************************
'Flughafen Paderborn-Lippstadt
'********************************************************************
ATIS 118.27,80/2,(N51,36,55),(E8,37,2),24,0,0,0,
     "Paderborn - Lippstadt … Delta ‚ € Š - Altimeter 1021 - † - ‡ Œyou have Delta ... ILS Freq 24 NAV 111.7 ..."
 
'--------------------------------------------------------------------
'Lande-/Startbahnen definieren
'--------------------------------------------------------------------
AREA_TEST       (N51,36,55),      'Position n”rdl.Breite (G,M,S)
                (E08,37,02),      'Position ”stl. L„nge  (G,M,S)
                         25       'Reichweite (max.255)


RUNWAY          (N51,36,55),      'Position n”rdl.Breite (G,M,S)
                (E08,37,02),      'Position ”stl. L„nge  (G,M,S)
                        288,      'H”he in Meter
                        239,      'Anflugkurs der Runway in Grad
                       7300,      'L„nge in Fuá
                        160,      'Breite in Fuá
                         24,      'Nummer der Bahn (1-63)
                         ' 0,      'Buchstabe L =64, R =128, C =192
             
'          Bahn-Oberfl„che:


                        ' 0,      'graues Muster
                          1,      'beton hell, m.Punkten
                        ' 2,      'beton dunkel, m.Streifen         
                        ' 3,      'grasartig


 '        Bahn-Markierungen:
          
                 1+2+4+8+16+32,   'Seitenlinien
                         '2+      'Schwellenmarkierungen
                         '4+      'Landemarkierungen
                         '8+      'Abstandsmarkierungen (breit)
                        '16+      'Mittellinie
                        '32,      'Darstellung der Beschriftung
                        ' 64,      'Abstandsmarkierungen (schmal)
          
 '         Bahn-Beleuchtung:
                 
                        ' 0,      'keine
                        ' 1,      'an den Seiten
                        ' 4,      'in der Mitte
                          5,      'an den Seiten und in der Mitte
           
 '              Bahn-Beginn:              
  
                          1,      'Schwellenmarkierung an/aus 1/0
                       1010,      'Markierung Typ1 an/aus 1010/0
                          0,      'Markierung Typ2 an/aus 1010/0
                        ' 2,      'Anflugbefeuerung MALSR
                        ' 6,      '  "  ALSF-1
                          7,      '  "  ALSF-2
                         19,      '  "  Zahl der Blitzlichter
                           
 '                Bahn-Ende:
              
                          1,      'Schwellenmarkierung an/aus 1/0
                       1010,      'Markierung Typ1 an/aus 1010/0
                          0,      'Markierung Typ2 an/aus 1010/0
                        ' 2,      'Anflugbefeuerung MALSR
                          6,      '  "  ALSF-1
                       '  7,      '  "  ALSF-2
                         11,      '  "  Zahl der Blitzlichter


 'Sichtflug-Gleitwinkelanzeigesystem 1:
 
                        ' 0,      'kein
                        ' 1,      '2 Balken
                          2,      '3 Balken
                          3,      'Winkel der Balken in Grad


 'Sichtflug-Gleitwinkelanzeigesystem 2:
 
                        ' 0,      'kein
                          1,      '2 Balken
                        ' 2,      '3 Balken
                          3       'Winkel der Balken in Grad


'--------------------------------------------------------------------
'Navigationshilfen
'--------------------------------------------------------------------


'include "navtest.inc"


 NDB                  354.0,      'Frequenz
                      30000,      'Reichweite in Meter /2048
                (N51,36,55),      'Position n”rdl.Breite (G,M,S)
                (E8, 38,25),      'Position ”stl. L„nge  (G,M,S)
                        288,      'H”he in Meter
                      "PAD",      'Kennung (max.5)
      "Paderborn-Lippstadt"       'Name (max.24)
 '--------------------------
 VOR                  108.5,      'Frequenz
                     120000,      'Reichweite in Meter
                        0.1,      'magnetische Abweichung in Grad
                (N51,36,55),      'Position n”rdl.Breite (G,M,S)
                (E8, 38,25),      'Position ”stl. L„nge  (G,M,S)
                        288,      'H”he in Meter
                      "PAD",      'Kennung (max.5)
      "Paderborn-Lippstadt",      'Name (max.24)
                          1       'DME vorhanden
 '--------------------------
 ILS                  111.7,      'Frequenz
                      50000,      'Reichweite in Meter
                          0,      'magnetische Abweichung in Grad
           (N51,36,37.8764),      'Position n”rdl.Breite (G,M,S)
           (E08,36,16.2401),      'Position ”stl. L„nge  (G,M,S)
                        288,      'H”he in Meter
                      "PAD",      'Kennung (max.5)
      "Paderborn-Lippstadt",      'Name (max.24)
                   1+64+128,      'DME + Gleitwegsender + Empfindlichkeit


                        239,      'Anflugkurs in Grad


      'Gleitwegsender:


           (N51,37,04.0557),      'Position n”rdl.Breite (G,M,S)
           (E08,37,26.3361),      'Position ”stl. L„nge  (G,M,S)
                        288,      'H”he in Meter
                          3       'Winkel in Grad




'           (N51,36,50.7359),      'Position n”rdl.Breite (G,M,S)
'           (E08,36,50.7462),      'Position ”stl. L„nge  (G,M,S)


 '--------------------------
 INNER_MARKER  (N51,37,13.3965),      'Position n”rdl.Breite (G,M,S)
               (E08,37,51.0021),      'Position ”stl. L„nge  (G,M,S)
                            288       'H”he in Meter
 MIDDLE_MARKER (N51,38,32.2371),      'Position n”rdl.Breite (G,M,S)
               (E08,41,22.4972),      'Position ”stl. L„nge  (G,M,S)
                            288       'H”he in Meter
 OUTER_MARKER  (N51,40,22.8508),      'Position n”rdl.Breite (G,M,S)
               (E08,46,18.7887),      'Position ”stl. L„nge  (G,M,S)
                            288       'H”he in Meter
 '--------------------------


'--------------------------------------------------------------------
'Bodenfl„chen
'--------------------------------------------------------------------
include "betflae.inc"
'--------------------------------------------------------------------
'Taxi Ways
'--------------------------------------------------------------------
include "txwayss.inc"
'--------------------------------------------------------------------
'Airport definieren
'--------------------------------------------------------------------
$f3os=$RefPointSecH/100000
$f3ns=$RefPointSecV/100000
$f3og=$f3os/60/60/100*100 $f3og=$f3og-0.5 $f3og=$f3og/1000*1000
$f3ng=$f3ns/60/60/100*100 $f3ng=$f3ng-0.5 $f3ng=$f3ng/1000*1000
$f4=$f3og*60*60 $f3os=$f3os-$f4
$f4=$f3ng*60*60 $f3ns=$f3ns-$f4  $f3om=$f3os/60/100*100 $f3om=$f3om-0.5 $f3om=$f3om/1000*1000


$f3nm=$f3ns/60/100*100 $f3nm=$f3nm-0.5 $f3nm=$f3nm/1000*1000
$f4=$f3om*60 $f3os=$f3os-$f4
$f4=$f3nm*60 $f3ns=$f3ns-$f4
     
AIRPORT (0~$f3ng,$f3nm,3~$f3ns),  'Position n”rdl.Breite (G,M,S)
        (0~$f3og,$f3om,3~$f3os),  'Position ”stl. L„nge  (G,M,S)
                        288,      'H”he in Meter
                        239,      'Anflugkurs der Runway in Grad
      "Paderborn-Lippstadt",      'Name (max.24)
                     118.27,      'Frequenz   COM1 in MHz
                     168.0 ,      'Frequenz   NAV1 in MHz
                          0,      'Azimutkurs NAV1 in Grad
                     173.0 ,      'Frequenz   NAV2 in MHz
                          0       'Azimutkurs NAV2 in Grad


'********************************************************************
'Geb„ude
'********************************************************************
$label=-1 $1=-1
include "tower.inc"
include "haus01.inc"
include "tank1.inc"
include "tank2.inc"
include "tank3.inc"
include "tank4.inc"
include "1hangar.inc"
include "2hangar.inc"
include "baracke.inc"
'***********************************************************
END

[Gnom67]

Ich muss korrigieren:
Die Position im Pfad ist immer bekannt, da der Pfad abgefahren wird.

Wie kommst du zu der Aussage? Wenn du einen Pfad irgendwie definierst und dann VERSUCHST ihn abzufahren, ist die Position noch lange nicht bekannt. So genau lässt sich gar kein Gerät steuern (ohne irgendeine Referenz), dass es nicht nach mehr oder minder vielen Bewegungen zwischen den Punkten A und B (oder weiteren) zu Abweichungen kommt. Wenn es so einfach wäre, müsstest du ja gar keinen Aufwand machen. Dann würde die Bewegungsanweisung ja völlig reichen. 3m vor, 2m links, 1,5m vor, 2m rechts. Ziel erreicht. Aber so einfach ist es nicht. Es sei denn, du bist damit zufrieden, wenn du dem Roboter alle paar mal eine Korrektur per Hand verpassen musst. Dann bist du der Sensor, der die Referenz erfasst.
Wenn du es schaffst, wenigstens halbwegs in die Zielregion zu kommen oder regelmäßig an einer geeigneten Stelle vorbei zu fahren, kannst du vielleicht diese eine Stelle als Referenz nehmen. Wenn der Roboter an einer Raumecke vorbei kommt, könntest du ihn dort sozusagen kalibrieren. der Pfad soll genau 15 cm von den beiden Wänden der Raumecken entfernt verlaufen.Du misst die Entfernung zu den beiden Wänden und kannst dann die Position so korrigieren, dass der Roboter auf dem Sollpfad liegt. Wenn die Abweichungen sonst nicht erheblich sind, kannst du bei jeder Fahrt an dieser Stelle korrigieren, so dass sich die Abweichungen nicht über viele Fahrten aufsummieren. Das wäre aber ein noch recht wenig flexibles System.

[Moppi]

Wie kommst du zu der Aussage?

Es sollten Bewegungsmuster entstehen. Idealer Weise, wenn die Strecke in einem Stück angelernt wird, sollte auch nur ein Bewegungsmuster entstehen. Mit jeder Korrektur oder Änderung durch Anlernen entstehen neue Muster. Theoretisch kann man sich ein ideales Muster vorstellen, das also dem Pfad entspricht, bzw. bei Abarbeitung dem Pfad wiedergibt. Beim Anwenden des Musters ist bekannt, welche Position im Muster abgearbeitet wird. Weil jede Position, im Muster, nicht zufällig gewählt wird, sondern die beruht auf Abhängigkeiten, von Umgebungs- und Bewegungsparametern. Durch Bewegungsmuster lässt sich ein Rückschluss auf die Position im Raum ziehen, weil alle Bewegungen einen Bezug zum Raum haben.

Beispiel: Wenn ich ein Bewegungsmuster mit "drei Schritten" nach vorn trainiere und dieses Muster abarbeite, befinde ich mich am Anfang der Bewegung auf Position 0 und am Ende der Bewegung auf Position 3. Die Distanz wir durch "Schritt" definiert. Damit steht eine Position fest, auch wenn sie nur relativ angegeben werden kann und nicht genau ist. Wenn ich morgens aufwache und gehe in die Küche, kenne ich meine genaue Position im Raum (nach Koordinaten) auch nicht.
Abweichungen spielen keine große Rolle. Schlimmstenfalls führt es zur Desorientierung, ich habe mich dann verirrt.

Das wäre aber ein noch recht wenig flexibles System.

Was soll das System tun? Zielsetzung ist, von Punkt zu Punkt zu fahren, wobei dem Roboter der Weg gezeigt wird.

Ist beim Mensch genauso so. Entweder ich habe einen Plan, dann gehe ich nach dem von einem Raum zum andern, zielgerichtet. Oder ich folge einer anderen Person. Oder ich folge einer Wegbeschreibung. Habe ich vom Wohnzimmer aus dann die Toilette gefunden, kenne ich den Weg. Damit bin ich aber auch nur so flexibel, dass ich den Weg zur Toilette finde und zurück. Das Auffinden der übrigen Räume müsste ich erst noch lernen.

Nachtrag:

Das Verfahren könnte an der Menge benötigten Speichers, bzw. an der Verarbeitungsgeschwindigkeit, die mit der Datenmenge zunimmt, scheitern. Die Flexibilität ergibt sich aus der Menge gespeicherter Daten und deren Verarbeitung. Das bedeutet, zunächst ausprobieren und die einzelnen Eingabeparameter auf das Nötigste relativieren. Dann könnte ich die anfallende Datenmenge abschätzen. Durch Priorisieren der Eingabeparameter kann die weiter gering gehalten werden, dadurch steigt die Ausführungssicherheit; aber es sinkt die Flexibilität bezüglich der situativen Wiedererkennung (Ähnlichkeit).
Daher kann ich nur hoffen, dass 3MB Speicher und 80MHz eines nodeMCU, genügen. Nach meinen bisherigen Schätzungen könnte das knapp werden. Aber gut, letztens war ich beim Zahnarzt und musste mich etwas festlegen, wann ich da sein werde und ich habe dann - unter Vorbehalt einiger Minuten Abweichung - eine Zeit genannt; als ich dann angekommen war, hat sich gezeigt, dass das sehr sehr knapp war (was ich aber auch vorher aus dem Bauch heraus wusste), da ich praktisch auf die Minute da war (ca. 60s bis 80s früher).



MfG

[Gnom67]

Ich kann deinen Ausführungen nur schwer folgen. Wenn du morgens aufstehst, gehst du doch nicht drei Schritte vor und dann drei Schritte links, sondern du benutzt deine Sensoren (Augen), um zu navigieren. Der Pfad und das Schrittmuster alleine genügt dir nicht. Mit jeder kleinen Abweichung kommst du weiter vom Pfad ab und am Ende rennst du gegen einen Türpfosten. Und jetzt sag nicht: "Dafür hab ich ja die Ultraschallsensoren." Das ist nämlich das, was ich die ganze Zeit sage. Du hast gesagt: "Die Position im Pfad ist immer bekannt, da der Pfad abgefahren wird."

Ich klink mich hier aus - das führt alles zu nichts.

[Moppi]

Hallo Gnom67!

Ich kann deinen Ausführungen nur schwer folgen. Wenn du morgens aufstehst, gehst du doch nicht drei Schritte vor und dann drei Schritte links, sondern du benutzt deine Sensoren (Augen), um zu navigieren.

Das ist nur bedingt richtig. Vieles machen wir automatisch, weil wir es jeden Tag wieder tun, immer gleich oder ähnlich. Das kann auch dazu führen, dass ich als Mensch erst das Muster abspule und dann Sensordaten auswerte. Wenn das dann hinterher nicht zusammenpasst, kann es sein, dass ich z.B. ausrutsche - das nennt man dann Unfall.

Und jetzt sag nicht: "Dafür hab ich ja die Ultraschallsensoren." Das ist nämlich das, was ich die ganze Zeit sage. Du hast gesagt: "Die Position im Pfad ist immer bekannt, da der Pfad abgefahren wird."

Beides gehört zusammen. Aufgrund der Sensordaten kann mit einer Wahrscheinlichkeit sagen, was als nächstes passieren muss, das ist in den Daten gespeichert. Als Grundregel würde ich hier nennen: Suche den passendsten, nächsten Schritt. Sollte es zu Problemen kommen, können die Sensoren in ihrer Gewichtung der Priorität nachjustiert werden. Im ungünstigsten Fall muss die Auflösung der Sensordaten erhöht werden; ungünstig deshalb, weil dann mehr Lernphasen notwendig sind und damit die Datenmenge und die Ausführungszeit, zur Entscheidungsfindung, zunimmt.

Mit jeder kleinen Abweichung kommst du weiter vom Pfad ab und am Ende rennst du gegen einen Türpfosten.

Das ist richtig. Du hast schon eine mögliche Lösung vorgestellt. So was in der Richtung muss es natürlich geben. Weil ich es mit zwei Motoren zu tun habe, die die Richtung bestimmen. Im Grunde ein Linienfolger-Mechanismus, der sich nur nicht an einer Linie auf dem Boden orientiert (die zwischen zwei Sensoren verläuft), sondern an außerhalb liegenden Merkmalen, per Ultraschall (hier wieder sehr ähnlich zu dem Mechanismus, an einer Wand lang zu fahren). Ich werde also zwei Dinge brauchen. Die Wegfindung per erlernten Daten, wobei sich der Roboter - stark vereinfacht - von Datum zu Datum bewegt und die Richtungskorrektur. Die Richtungskorrektur könnte man vielleicht für den Roboter selbst erlernbar machen, weil aufgrund der Sensordaten irgendwann klar ist, dass er kollidiert (in einem intelligenteren Szenario der Steuerung könnte man auch sagen: vom Weg abweicht).

Ich klink mich hier aus - das führt alles zu nichts.

Trotzdem herzlichen Dank, für Deine Anregungen, bezüglich der Probleme! Damit hast Du schon sehr weitergeholfen.
Was Du geschrieben hast, lese ich mir, zu gegebener Zeit, auch nochmal durch. Ich lese hier oft Sachen doppelt und dreifach. Manchmal verbergen sich Hinweise, die man beim ersten Lesen übersehen hat.



MfG


- - - Aktualisiert - - -

Natürlich auch besten Dank, an alle, die sich bisher beteiligt haben! =D> ("Applaus")

- - - Aktualisiert - - -

Ich gebe dem Ding (meinem Verfahren) jetzt erst einmal einen Namen, bis ich ein Verfahren irgendwo finde, dass genau dieses beschreibt: implicitly learned path navigation, kurz ILPN
Es kann natürlich auch sein, dass es in bisher verwendeten Verfahren versteckt ist, die mit "Landmarken" funktionieren.

Und eine Beschreibung:

Bezeichnet ein Verfahren, nach dem Roboter einem Weg folgen lernen, ohne dass sie sich dessen bewusst sind, wie dies genau geschieht oder dass der Weg berechnet würde. Hierfür wird keine Karte benötigt, sondern die auf dem Weg erfassten Informationen (Sensordaten) werden gespeichert; es werden zusätzlich Daten gespeichert, die einen Schluss auf vorherige Schritte und folgende Schritte zulassen und eine Verbindung herstellen. Der Weg wird auch auch als "Pfad" oder engl. "path" bezeichnet. Aus den impliziten Daten können explizite Daten gewonnen werden, so dass daraus auch eine mehr oder weniger scharfe Skizze der Umgebung erstellt werden kann. ILPN funktioniert nicht aufgrund absoluter Positionen (wie Koordinaten), sondern stellt eine relative Navigation, basierend auf erlerntem Wissen dar.


Nachtrag:

In einer ganz einfachen Variante habe ich so ein Verfahren, im Ansatz, bereits am 26.12.2018, 18:52 hier in meinem Blog veröffentlicht: https://www.roboternetz.de/community...eb-3-Quelltext
Zum besseren Verständnis kann dort der gesamte Quelltext eingesehen werden, wie er damals existierte.

----------------------------------------------------------------------------
Der Vollständigkeit halber habe ich nochmals gesucht, nachdem mir einige Dinge klarer geworden sind. Das Stichwort Landmarken ist ja schon gefallen. Dazu gibt es auch zig Quellen, am Ende dieses Dokumentes, die sich dann wohl allesamt mit Details der Navigation, basierend auf Karten und Marken, befassen: Unifying Map and Landmark Based Representations for Visual Navigation

[Moppi]

Wenn Du ein wenig Geld ausgeben willst, kannst Du es mit UWB-Baken
versuchen

Der Link für die Auswertung funktioniert nicht mehr. Ich habe bisher nichts gefunden. Die Arduino-Bibliothek schon. Bloß, ich muss mir das erst mal bildlich vorstellen können. Dafür frage ich mich gerade, welche Daten man von so einer Bake bekommt.

In einem Video habe ich gerade gesehen, dass man da offenbar die Entfernung und die Signalstärke bekommt. Mehr muss ich erst mal nicht wissen.


MfG