localhorst/LocationHub
SHA256
1
0
Fork 0
Code Issues 2 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

feat: tracker location based on multiple location providers #5

Merged
localhorst merged 19 commits from feature/ttn-location-algo into main 2025-01-02 14:57:34 +01:00
Conversation 4 Commits 19 Files Changed 9
+124 -73
1 changed files with 124 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 6d20f4e54c - Show all commits
server/src/eventHandler/ttnMessageReceivedEventHandler.ts
+124 -73
View File
@@ -11,6 +11,119 @@ import { getLocationForWifiMemoized } from "../proxy/wigle";
const locationService = container.resolve(LocationService);
const wifiScanService = container.resolve(WifiScanService);
const CalculateTtnGatewayLocation = async (event: TtnMessageReceivedEvent) => {
// Get location based on TTN Gateways
const virtualLocation = {
latitude: undefined as number | undefined,
longitude: undefined as number | undefined,
};
if (!event.ttnGateways || event.ttnGateways.length === 0) {
localhorst marked this conversation as resolved Outdated
Pheanox commented 2024-12-31 16:15:45 +01:00
Outdated
Review
Copy Link
Copy Source

Das ! kann weg.

Das ! kann weg.
Pheanox commented 2024-12-31 16:17:19 +01:00
Outdated
Review
Copy Link
Copy Source

Bzw. kann alles weg, wird nicht verwendet

Bzw. kann alles weg, wird nicht verwendet
console.log("No TTN Gateway location received!")
} else {
let totalWeight = 0;
let weightedLatitude = 0;
localhorst marked this conversation as resolved Outdated
Pheanox commented 2024-12-31 16:16:31 +01:00
Outdated
Review
Copy Link
Copy Source

Ich würde nach dem console.log ein return machen. Dann sparst du dir die else

Ich würde nach dem console.log ein return machen. Dann sparst du dir die else
localhorst commented 2025-01-01 21:41:19 +01:00
Outdated
Review
Copy Link
Copy Source

ne, dann würdest ja evtl. die Location von GNSS oder Wifi nicht "parsen"

ne, dann würdest ja evtl. die Location von GNSS oder Wifi nicht "parsen"
Pheanox commented 2025-01-01 22:13:58 +01:00
Outdated
Review
Copy Link
Copy Source

Ich hätte es so aufgebaut Vorschlag:
Für jede Berechnung eine eigene Funktion die die Werte ausrechnet und dann zurück gibt:

const CalculateTtngatewayLocation = (event: TtnMessageReceivedEvent) => {
//... do stuff
return {
gnss_latitude: virtualLocation.latitude,
gnss_longitude: virtualLocation.longitude,
};
};

In der "Hauptfunktion" dann prüfen ob die werte da sind und wenn ja die Funktion aufrufen und die Werte zuweisen:
var location: Partial<Location> = {};

`// Get location based on TTN Gateways`
`if (event.ttnGateways && event.ttnGateways.length > 0) {`
  `// Option 1`
  `const virtualLocation = CalculateTtngatewayLocation(event);`
  `location.ttn_gw_latitude = virtualLocation.gnss_latitude;`
  `location.ttn_gw_longitude = virtualLocation.gnss_latitude;`

  `// Option 2`
  `const virtualLocation = CalculateTtngatewayLocation(event);`
 `location = { ...location, ...virtualLocation };`

  `// Option 3 -> fancy :D`
  `location = { ...location, ...CalculateTtngatewayLocation(event) };`
  `}`

So werden drei if else zu drei if und man hat weniger Komplexität in einer Funktion.

Ich hätte es so aufgebaut Vorschlag: Für jede Berechnung eine eigene Funktion die die Werte ausrechnet und dann zurück gibt: `const CalculateTtngatewayLocation = (event: TtnMessageReceivedEvent) => {` `//... do stuff` `return {` `gnss_latitude: virtualLocation.latitude,` `gnss_longitude: virtualLocation.longitude,` `};` `};` In der "Hauptfunktion" dann prüfen ob die werte da sind und wenn ja die Funktion aufrufen und die Werte zuweisen: `var location: Partial<Location> = {};` `// Get location based on TTN Gateways` `if (event.ttnGateways && event.ttnGateways.length > 0) {` `// Option 1` `const virtualLocation = CalculateTtngatewayLocation(event);` `location.ttn_gw_latitude = virtualLocation.gnss_latitude;` `location.ttn_gw_longitude = virtualLocation.gnss_latitude;` `// Option 2` `const virtualLocation = CalculateTtngatewayLocation(event);` `location = { ...location, ...virtualLocation };` `// Option 3 -> fancy :D` `location = { ...location, ...CalculateTtngatewayLocation(event) };` `}` So werden drei if else zu drei if und man hat weniger Komplexität in einer Funktion.
let weightedLongitude = 0;
event.ttnGateways.forEach(gw => {
const weight = 1 / Math.abs(gw.rssi); // Higher RSSI (closer to 0) gives more weight
totalWeight += weight;
weightedLatitude += gw.latitude * weight;
weightedLongitude += gw.longitude * weight;
});
// Calculate the weighted average to get the virtual location
const virtualLocation = {
latitude: weightedLatitude / totalWeight,
longitude: weightedLongitude / totalWeight
};
console.log("Tracker location based on TTN Gateway location:", virtualLocation);
}
return {
ttn_latitude: virtualLocation.latitude,
ttn_longitude: virtualLocation.longitude,
};
};
const CalculateWifiLocation = async (event: TtnMessageReceivedEvent) => {
// Get location based on WiFi Scans
const virtualLocation = {
latitude: undefined as number | undefined,
longitude: undefined as number | undefined,
};
if (!event.wifis || event.wifis.length === 0) {
console.log("No WiFi scans received!")
} else {
// Process Wi-Fi data to compute weighted location
const wifiScans = await Promise.all(
event.wifis.map(async (wifi) => {
localhorst marked this conversation as resolved Outdated
Pheanox commented 2025-01-01 22:50:42 +01:00
Outdated
Review
Copy Link
Copy Source

Der Wifi eintrag wird nur die die Datenbank geschrieben, wenn es eine Location gibt, sollte dieser nicht auch ohne reingeschrieben werden mit latitude und longitude undefined? Ansonsten würde ich es in drei steps unterteilen: Api Call, Datenbank entry erstellen, totalWeight + weightedLatitude + weightedLongitude ausrechnen. Ich glaube das macht es übersichtlicher ist aber vermutlich Geschmackssache. Mein Vorschlag:

` const wifiScans = await Promise.all(
event.wifis.map(async (wifi) => {
const apiResponse = await getLocationForWifiMemoized(wifi.mac);

      return {
        lp_ttn_end_device_uplinks_id: event.lp_ttn_end_device_uplinks_id,
        mac: wifi.mac,
        rssi: wifi.rssi,
        latitude: apiResponse?.results[0]?.trilat,
        longitude: apiResponse?.results[0]?.trilong,
      };
    })
  );

  await wifiScanService.createWifiScans(wifiScans);

  const { totalWeight, weightedLatitude, weightedLongitude } =
    wifiScans.reduce(
      (acc, { latitude, longitude, rssi }) => {
        if (latitude && longitude && rssi !== 0) {
          const weight = 1 / Math.abs(rssi);

          acc.totalWeight += weight;
          acc.weightedLatitude += latitude * weight;
          acc.weightedLongitude += longitude * weight;
        }

        return acc;
      },
      {
        totalWeight: 0,
        weightedLatitude: 0,
        weightedLongitude: 0,
      }
    );

  const virtualLocation = {
    latitude: weightedLatitude / totalWeight,
    longitude: weightedLongitude / totalWeight,
  };`
Der Wifi eintrag wird nur die die Datenbank geschrieben, wenn es eine Location gibt, sollte dieser nicht auch ohne reingeschrieben werden mit latitude und longitude undefined? Ansonsten würde ich es in drei steps unterteilen: Api Call, Datenbank entry erstellen, totalWeight + weightedLatitude + weightedLongitude ausrechnen. Ich glaube das macht es übersichtlicher ist aber vermutlich Geschmackssache. Mein Vorschlag: ` const wifiScans = await Promise.all( event.wifis.map(async (wifi) => { const apiResponse = await getLocationForWifiMemoized(wifi.mac); return { lp_ttn_end_device_uplinks_id: event.lp_ttn_end_device_uplinks_id, mac: wifi.mac, rssi: wifi.rssi, latitude: apiResponse?.results[0]?.trilat, longitude: apiResponse?.results[0]?.trilong, }; }) ); await wifiScanService.createWifiScans(wifiScans); const { totalWeight, weightedLatitude, weightedLongitude } = wifiScans.reduce( (acc, { latitude, longitude, rssi }) => { if (latitude && longitude && rssi !== 0) { const weight = 1 / Math.abs(rssi); acc.totalWeight += weight; acc.weightedLatitude += latitude * weight; acc.weightedLongitude += longitude * weight; } return acc; }, { totalWeight: 0, weightedLatitude: 0, weightedLongitude: 0, } ); const virtualLocation = { latitude: weightedLatitude / totalWeight, longitude: weightedLongitude / totalWeight, };`
// Create new WiFi Scan entry if wigle.net reported location
const apiResponse = await getLocationForWifiMemoized(wifi.mac);
return {
lp_ttn_end_device_uplinks_id: event.lp_ttn_end_device_uplinks_id,
mac: wifi.mac,
localhorst marked this conversation as resolved Outdated
Pheanox commented 2025-01-01 22:27:46 +01:00
Outdated
Review
Copy Link
Copy Source

await wifiScanService.createWifiScan

await wifiScanService.createWifiScan
rssi: wifi.rssi,
latitude: apiResponse?.results[0]?.trilat,
longitude: apiResponse?.results[0]?.trilong,
};
})
);
await wifiScanService.createWifiScans(wifiScans);
localhorst marked this conversation as resolved Outdated
Pheanox commented 2025-01-01 22:28:00 +01:00
Outdated
Review
Copy Link
Copy Source

await kann weg

await kann weg
const { totalWeight, weightedLatitude, weightedLongitude } =
wifiScans.reduce(
(acc, { latitude, longitude, rssi }) => {
if (latitude && longitude && rssi !== 0) {
const weight = 1 / Math.abs(rssi);
localhorst marked this conversation as resolved Outdated
Pheanox commented 2025-01-01 22:28:10 +01:00
Outdated
Review
Copy Link
Copy Source

await kann weg

await kann weg
acc.totalWeight += weight;
acc.weightedLatitude += latitude * weight;
acc.weightedLongitude += longitude * weight;
}
return acc;
},
{
totalWeight: 0,
weightedLatitude: 0,
weightedLongitude: 0,
}
);
// Calculate the weighted average to get the virtual location
virtualLocation.latitude = weightedLatitude / totalWeight;
virtualLocation.longitude = weightedLongitude / totalWeight;
console.log("Tracker location based on WiFi Scan location:", virtualLocation);
}
return {
wifi_latitude: virtualLocation.latitude,
wifi_longitude: virtualLocation.longitude,
};
};
const CalculateGnssLocation = async (event: TtnMessageReceivedEvent) => {
// Default virtual location with undefined coordinates
const virtualLocation = {
latitude: undefined as number | undefined,
longitude: undefined as number | undefined,
};
if (virtualLocation.latitude === undefined || virtualLocation.longitude === undefined) {
console.log("No valid GNSS location received!");
}
return {
gnss_latitude: virtualLocation.latitude,
gnss_longitude: virtualLocation.longitude,
};
};
domainEventEmitter.on(
TtnMessageReceivedEventName,
async (event: TtnMessageReceivedEvent) => {
@@ -23,83 +136,21 @@ domainEventEmitter.on(
var ttn_gw_based_latitude: number | undefined = undefined;
var ttn_gw_based_longitude: number | undefined = undefined;
// Get location based on TTN Gateways
if (!event.ttnGateways || event.ttnGateways.length === 0) {
console.log("No TTN Gateway location received!")
} else {
let totalWeight = 0;
let weightedLatitude = 0;
let weightedLongitude = 0;
event.ttnGateways.forEach(gw => {
const weight = 1 / Math.abs(gw.rssi); // Higher RSSI (closer to 0) gives more weight
totalWeight += weight;
weightedLatitude += gw.latitude * weight;
weightedLongitude += gw.longitude * weight;
});
// Calculate the weighted average to get the virtual location
const virtualLocation = {
latitude: weightedLatitude / totalWeight,
longitude: weightedLongitude / totalWeight
};
console.log("Tracker location based on TTN Gateway location:", virtualLocation);
ttn_gw_based_latitude = virtualLocation.latitude;
ttn_gw_based_longitude = virtualLocation.longitude;
if (event.ttnGateways && event.ttnGateways.length > 0) {
const virtualLocation = await CalculateTtnGatewayLocation(event);
ttn_gw_based_latitude = virtualLocation.ttn_latitude;
ttn_gw_based_longitude = virtualLocation.ttn_longitude;
}
// Get location based on WiFi Scans
if (!event.wifis || event.wifis.length === 0) {
console.log("No WiFi scans received!")
} else {
let totalWeight = 0;
let weightedLatitude = 0;
let weightedLongitude = 0;
// Process Wi-Fi data to compute weighted location
await Promise.all(
event.wifis.map(async (wifi) => {
const apiResponse = await getLocationForWifiMemoized(wifi.mac);
if ((apiResponse != undefined) && (apiResponse?.totalResults > 0)) {
// Create new WiFi Scan entry if wigle.net reported location
const newWifiScan = wifiScanService.createWifiScan({
lp_ttn_end_device_uplinks_id: event.lp_ttn_end_device_uplinks_id,
mac: wifi.mac,
rssi: wifi.rssi,
latitude: apiResponse?.results[0]?.trilat,
longitude: apiResponse?.results[0]?.trilong,
})
// Calculate weight based on RSSI (higher signal strength gives more weight)
const weight = 1 / Math.abs((await newWifiScan).rssi);
totalWeight += weight;
// Accumulate weighted latitude and longitude
weightedLatitude += (await newWifiScan).latitude * weight;
weightedLongitude += (await newWifiScan).longitude * weight;
}
})
);
// Calculate the weighted average to get the virtual location
const virtualLocation = {
latitude: weightedLatitude / totalWeight,
longitude: weightedLongitude / totalWeight
};
console.log("Tracker location based on WiFi Scan location:", virtualLocation);
wifi_based_latitude = virtualLocation.latitude;
wifi_based_longitude = virtualLocation.longitude;
if (event.wifis && event.wifis.length > 0) {
const virtualLocation = await CalculateWifiLocation(event);
wifi_based_latitude = virtualLocation.wifi_latitude;
wifi_based_longitude = virtualLocation.wifi_longitude;
}
// Get location based on GNSS
if ((event.gnssLocation.latitude) && (event.gnssLocation.longitude)) {
gnss_based_latitude = event.gnssLocation.latitude;
gnss_based_longitude = event.gnssLocation.longitude;
} else {
console.log("No GNSS location received!")
}
const virtualLocation = await CalculateGnssLocation(event);
gnss_based_latitude = virtualLocation.gnss_latitude;
gnss_based_longitude = virtualLocation.gnss_longitude;
const newLocation = await locationService.createLocation({
lp_ttn_end_device_uplinks_id: event.lp_ttn_end_device_uplinks_id,