Her er en detaljeret teknisk beskrivelse af, hvordan ESP32 + LoRa mesh-netværk kunne bruges til detection og registrering af fremmede mobilenheder og droner (f.eks. fra ikke-EU-lande) i et tæt landsdækkende netværk. Løsningen kombinerer RF-sniffing, signalanalyse, mesh-kommunikation og centraliseret databehandling.

Et sådant system ville bestå af distribuerede sensor-noder (ESP32 + LoRa) og en central server, der:

• Detekterer mistænkelige enheder via RF-signalanalyse (Wi-Fi, Bluetooth, 4G/5G, drone-telemetri).
• Sender data gennem et LoRa mesh-netværk til en central database.
• Analyserer data for at identificere fremmede enheder (f.eks. ukendte MAC-adresser, IMEI, drone-protokoller).
• Alerter myndigheder ved mistænkelig aktivitet.

For at opfange mobilenheder og droner skal noderne bruge flere sensorer og teknikker:

For at opnå landsdækkende dækning skal systemet bruge et mesh-netværk, hvor hver node kan:

• Detektere enheder lokalt.
• Videreformidle data til nabonoder (hvis direkte forbindelse til gateway mangler).
• Sende data til en central server via LoRaWAN eller proprietært mesh-protokol.

[ESP32 + LoRa + Sensorer] ——(LoRa Mesh)——> [ESP32 + LoRa + Sensorer]
       |                                               |
       ▼                                               ▼
[LoRa Gateway] ——(Ethernet/4G/5G)——> [Central Server (Cloud/On-Premise)]

• Mesh-noder: ESP32 + LoRa-modul (f.eks. SX1276, SX1262, RFM95W).
• Gateways: ESP32 + LoRa + Ethernet/4G (f.eks. Raspberry Pi + LoRa HAT).
• Central Server: Database (PostgreSQL, InfluxDB) + Analyse (Python, AI/ML).

💡 Anbefaling:

Meshtastic er det bedste valg til LoRa mesh med ESP32, da det:

• Understøtter hop-by-hop (data kan springe mellem noder).
• Er åben source og nemt at tilpasse.
• Kan integreres med ESP32 via UART/SPI.

Hver node består af:

⚠️ Bemærk:
* RTL-SDR kræver en USB-host (f.eks. Raspberry Pi Zero som co-processor).
* LoRa-moduler skal bruge 868 MHz (EU) eller 915 MHz (US).
* Strømforbrug skal optimeres (f.eks. dyb søvn mellem scanninger).

Gateways forbinder LoRa mesh-netværket med internet (via Ethernet/4G/5G):

—

ESP32 kan scanne for Wi-Fi-enheder og logge:

• MAC-adresser
• SSID (netværksnavn)
• Signalstyrke (RSSI)
• Kanal
• Vendortypen (f.eks. Apple, Samsung, DJI)

#include <WiFi.h>
#include <esp_wifi.h>
 
void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  esp_wifi_set_promiscuous(true);
  esp_wifi_set_promiscuous_rx_cb(&wifi_sniffer_callback);
}
 
void wifi_sniffer_callback(uint8_t *buf, uint16_t len) {
  if (buf[0] == 0x40) { // Probe Request
    uint8_t *mac = &buf[10]; // MAC-adresse (6 bytes)
    int8_t rssi = buf[len - 1]; // Signalstyrke
    char macStr[18];
    sprintf(macStr, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
    Serial.printf("Detekteret enhed: MAC=%s, RSSI=%d dBm\n", macStr, rssi);
    // Send data via LoRa til mesh-netværket
    sendViaLoRa(macStr, rssi);
  }
}
 
void loop() {
  delay(1000);
}

ESP32 kan scanne for BLE-enheder (f.eks. mobiltelefoner, droner med BLE):

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEAdvertisedDevice.h>
 
class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
  void onResult(BLEAdvertisedDevice advertisedDevice) {
    Serial.printf("Detekteret BLE-enhed: MAC=%s, RSSI=%d, Navn=%s\n",
                  advertisedDevice.getAddress().toString().c_str(),
                  advertisedDevice.getRSSI(),
                  advertisedDevice.getName().c_str());
    // Send data via LoRa
    sendViaLoRa(advertisedDevice.getAddress().toString().c_str(), advertisedDevice.getRSSI());
  }
};
 
void setup() {
  Serial.begin(115200);
  BLEDevice::init("ESP32-BLE-Scanner");
  BLEScan *pBLEScan = BLEDevice::getScan();
  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());
  pBLEScan->setActiveScan(true);
  pBLEScan->start(30); // Scan i 30 sekunder
}
 
void loop() {
  delay(1000);
}

For at detektere droner og mobilnet (4G/5G) kan man bruge RTL-SDR med en Raspberry Pi (som co-processor) og sende resultater til ESP32 via UART:

Trin: 1. Raspberry Pi kører RTL-SDR + GNU Radio for at analysere RF-signalet. 2. ESP32 modtager detekterede frekvenser via UART. 3. ESP32 sender data via LoRa mesh til gateway.

from rtlsdr import RtlSdr
import numpy as np
 
sdr = RtlSdr()
sdr.sample_rate = 2.4e6  # 2.4 MHz (droner bruger ofte 2.4 GHz)
sdr.center_freq = 2.412e9  # 2.412 GHz (DJI-droner)
sdr.gain = 'auto'
 
def detect_drone():
    samples = sdr.read_samples(512*1024)  # Læs RF-samples
    fft = np.fft.fft(samples)
    freq = np.fft.fftfreq(len(samples), d=1/sdr.sample_rate)
    power = np.abs(fft)
    # Detekter top-frekvenser (droner har karakteristiske signaler)
    peak_freq = freq[np.argmax(power)]
    if 2.4e9 <= peak_freq <= 2.48e9:  # 2.4 GHz-bånd
        print(f"Drone detekteret på {peak_freq/1e6} MHz!")
        # Send til ESP32 via UART
        with open('/dev/ttyS0', 'w') as uart:
            uart.write(f"DRONE:{peak_freq}\n".encode())

ESP32 (UART-modtager):

void setup() {
  Serial.begin(115200); // Debug
  Serial1.begin(115200, SERIAL_8N1, 16, 17); // UART til Raspberry Pi
}
 
void loop() {
  if (Serial1.available()) {
    String data = Serial1.readStringUntil('\n');
    if (data.startsWith("DRONE:")) {
      float freq = data.substring(6).toFloat();
      Serial.printf("Drone detekteret på %.2f MHz\n", freq);
      // Send via LoRa
      sendViaLoRa("DRONE", freq);
    }
  }
}

ESP32 + INMP441 (I2S MEMS-mikrofon) kan analysere lydfrekvenser for at detektere droner:

#include <driver/i2s.h>
#include <arduinoFFT.h>
 
#define I2S_PORT I2S_NUM_0
#define SAMPLE_RATE 44100
#define BUFFER_SIZE 1024
 
arduinoFFT FFT = arduinoFFT();
double vReal[BUFFER_SIZE];
double vImag[BUFFER_SIZE];
 
void setup() {
  Serial.begin(115200);
  i2s_config_t i2s_config = {
    .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
    .sample_rate = SAMPLE_RATE,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_24BIT,
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
    .communication_format = I2S_COMM_FORMAT_STAND_I2S,
    .dma_buf_count = 8,
    .dma_buf_len = 1024,
    .use_apll = false,
    .tx_desc_auto_clear = false,
    .fixed_mclk = 0
  };
  i2s_pin_config_t pin_config = {
    .bck_io_num = 26,
    .ws_io_num = 25,
    .data_in_num = 34,
    .data_out_num = -1
  };
  i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
  i2s_set_pin(I2S_PORT, &pin_config);
}
 
void loop() {
  int16_t buffer[BUFFER_SIZE];
  size_t bytesRead;
  i2s_read(I2S_PORT, buffer, BUFFER_SIZE * sizeof(int16_t), &bytesRead, portMAX_DELAY);
 
  // Konverter til double for FFT
  for (int i = 0; i < BUFFER_SIZE; i++) {
    vReal[i] = buffer[i];
    vImag[i] = 0;
  }
 
  FFT.Windowing(vReal, BUFFER_SIZE, FFT_WIN_TYP_HAMMING, FFT_FORWARD);
  FFT.Compute(vReal, vImag, BUFFER_SIZE, FFT_FORWARD);
  FFT.ComplexToMagnitude(vReal, vImag, BUFFER_SIZE);
 
  // Tjek for drone-frekvenser (typisk 100–500 Hz for motorlyd)
  double peakFreq = FFT.MajorPeak(vReal, BUFFER_SIZE, SAMPLE_RATE);
  if (peakFreq > 100 && peakFreq < 500) {
    Serial.printf("Drone detekteret (lyd) på %.2f Hz\n", peakFreq);
    sendViaLoRa("DRONE_SOUND", peakFreq);
  }
}

—

Meshtastic er et åbent mesh-protokol for LoRa, der understøtter:

• Hop-by-hop (data springer mellem noder).
• GPS-positionering.
• Tekstmeddelelser og JSON-data.

Opsætning: 1. Flash Meshtastic-firmware på ESP32 (via PlatformIO). 2. Konfigurer LoRa-indstillinger (frekvens, SF, BW). 3. Send detekterede data som JSON via mesh.

Eksempel (Meshtastic + ESP32):

{
  "type": "detection",
  "node_id": "ESP32_001",
  "timestamp": "2026-09-13T12:00:00Z",
  "gps": {
    "lat": 55.6761,
    "lon": 12.5683
  },
  "detections": [
    {
      "type": "wifi",
      "mac": "A4:B1:E9:12:34:56",
      "rssi": -70,
      "ssid": "Unknown_Network",
      "vendor": "Apple"
    },
    {
      "type": "drone",
      "freq": 2412.0,
      "signal_type": "RF",
      "confidence": 0.95
    }
  ]
}

Hvis man ikke vil bruge Meshtastic, kan man implementere et simpelt flooding-protokol:

#include <SPI.h>
#include <LoRa.h>
 
#define LORA_CS    18
#define LORA_RST   14
#define LORA_IRQ   26
#define LORA_FREQ  868E6  // 868 MHz (EU)
 
void setup() {
  Serial.begin(115200);
  LoRa.setPins(LORA_CS, LORA_RST, LORA_IRQ);
  if (!LoRa.begin(LORA_FREQ)) {
    Serial.println("LoRa initialisering fejlede!");
    while (1);
  }
  LoRa.setSpreadingFactor(12);  // Længere rækkevidde
  LoRa.setSignalBandwidth(125E3);
}
 
void sendViaLoRa(String type, String data) {
  String message = "NODE:" + String(esp_getChipId()) + "|" + type + ":" + data;
  LoRa.beginPacket();
  LoRa.print(message);
  LoRa.endPacket();
  Serial.println("Sendt: " + message);
}
 
void loop() {
  // Modtag data fra andre noder
  int packetSize = LoRa.parsePacket();
  if (packetSize) {
    String received = "";
    while (LoRa.available()) {
      received += (char)LoRa.read();
    }
    Serial.println("Modtaget: " + received);
 
    // Flooding: Videreformidle meddelelsen (undgå loops med TTL)
    if (!received.startsWith("NODE:" + String(esp_getChipId()))) {
      sendViaLoRa("FWD", received);  // Videreformidle
    }
  }
  delay(100);
}

—

[LoRa Gateway] ——(4G/5G/Ethernet)——> [Central Server]
                                      |
                                      ▼
[Database] ——> [Analyse] ——> [Dashboard] ——> [Alarmer]

• Database: PostgreSQL (for struktureret data) + InfluxDB (for tidsserie-data).
• Analyse: Python (Pandas, Scikit-learn) til at identificere mistænkelige enheder.
• Dashboard: Grafana til visualisering.
• Alarmer: Slack, Email, SMS ved detektion.

1. Noder detekterer enheder og sender data via LoRa mesh. 2. Gateways modtager data og sender det til central server via HTTP/MQTT. 3. Server gemmer data i database og kører analyse. 4. Analyse identificerer:

• Ukendte MAC-adresser (sammenlignet med EU-databaser).
• Droner (via RF-signaturer, akustisk, IR).
• Mobilnet-enheder (via IMEI/TAC-lister).

5. Alarmer sendes til myndigheder (f.eks. politi, Forsvaret).

import pandas as pd
from datetime import datetime
 
# Læs data fra database
df = pd.read_sql("SELECT * FROM detections WHERE timestamp > NOW() - INTERVAL '1 hour'", con=engine)
 
# Liste over kendte EU-MAC-adresser (fiktivt eksempel)
eu_mac_prefixes = [
    "00:1A:79",  # Apple (EU)
    "00:1E:58",  # Google (EU)
    "00:23:12",  # Samsung (EU)
    # ... (flere)
]
 
# Filtrer ukendte MAC-adresser
unknown_macs = df[~df['mac'].str.startswith(tuple(eu_mac_prefixes))]
 
# Gem til alarmliste
if not unknown_macs.empty:
    unknown_macs.to_csv("unknown_devices.csv", index=False)
    send_alert("Ukendte enheder detekteret: " + str(unknown_macs['mac'].tolist()))

import numpy as np
from sklearn.ensemble import RandomForestClassifier
 
# Træningsdata: RF-signaturer for kendte droner
X_train = np.load("drone_rf_signatures.npy")  # Frekvens + amplitude
y_train = np.load("drone_labels.npy")        # 1 = drone, 0 = ikke drone
 
# Træn model
model = RandomForestClassifier()
model.fit(X_train, y_train)
 
# Forudsig nye detektioner
def predict_drone(rf_data):
    prediction = model.predict([rf_data])
    return prediction[0] == 1  # True = drone

⚠️ Vigtigt:
* Konsulter en jurist før implementering.
* Sørg for databeskyttelse (kryptering, anonymisering).
* Få godkendelse fra Erhvervsstyrelsen (for RF-udstyr) og Datatilsynet (for dataindsamling).

1. Hardware:

• ESP32 + RA-02 LoRa-modul + Wi-Fi/Bluetooth-antenne.
• Strømforsyning: USB (til test).

2. Software:

• Implementer Wi-Fi/Bluetooth sniffing (se eksempler ovenfor).
• Test LoRa-kommunikation mellem 2 ESP32-enheder.

3. Test:

• Placer noden i et testområde (f.eks. have).
• Verificer, at den kan detektere mobiltelefoner/droner og sende data via LoRa.

1. Hardware:

• 10–50 ESP32-noder med LoRa.
• 1–2 gateways (Raspberry Pi + LoRa + 4G).

2. Software:

• Flash Meshtastic på alle noder.
• Konfigurer mesh-netværk (samme frekvens, SF, BW).

3. Test:

• Placer noderne i et lille område (f.eks. bydel).
• Verificer, at data kan springe mellem noder (hop-by-hop).
• Mål rækkevidde og stabilitet.

1. Hardware:

• 1.000+ ESP32-noder (fordelt over landet).
• 100+ gateways (fordelt med 5–10 km afstand).
• Strømforsyning: Solpaneler + batterier.

2. Software:

• Central server (PostgreSQL + Grafana).
• AI/ML-modeller til automatisk detektion.

3. Deployment:

• Placer noderne på lygter, bygninger, master.
• Optimér placering for bedst dækning (simulering med RF-planning tools).

4. Vedligehold:

• Overvåg netværksstatus (f.eks. med Prometheus).
• Opdater firmware over-the-air (OTA).

1. Dataudveksling:

• API til PET (Politiets Efterretningstjeneste).
• Real-time alarmer til Forsvaret/Lufthavne.

2. Juridisk godkendelse:

• Søg tilladelse fra Erhvervsstyrelsen (RF-udstyr).
• Sikkerhedsgodkendelse fra Datatilsynet.

3. Test i praksis:

• Pilotprojekt i et begrænset område (f.eks. lufthavn).
• Evaluering af nøjagtighed og pålidelighed.

—

—

—

—

1. Start med en prototype (1–2 noder) for at teste detektion og LoRa-kommunikation. 2. Brug Meshtastic som mesh-protokol (nemt at implementere). 3. Kombiner flere sensorer (Wi-Fi + BLE + RF + akustisk) for bedre nøjagtighed. 4. Samarbejd med myndigheder (PET, Forsvaret) for juridisk godkendelse. 5. Brug AI/ML til at reducerer falske positiver. 6. Optimer strømforbrug med dyb søvn og solpaneler. 7. Skaler gradvist (start med byområder, derefter landdækning).

—

—

✅ Ja, det er teknisk muligt at opbygge et landsdækkende LoRa mesh-netværk med ESP32 til detection af fremmede mobilenheder og droner.

✅ Det ville kræve:

• 1.000+ ESP32-noder med LoRa + sensorer (Wi-Fi, BLE, RF, akustisk).
• 100+ gateways til central databehandling.
• AI/ML til filtrering af falske positiver.
• Samarbejde med myndigheder for juridisk godkendelse.

⚠️ Udfordringer:

• Juridiske barrierer (GDPR, telelovgivning).
• Strømforbrug (især for SDR/RF-sniffing).
• Falske positiver (kræver avanceret analyse).

🚀 Potentiale:

• Kosteffektivt (sammenlignet med radar).
• Skalerbart (kan dække hele Danmark).
• Fleksibelt (kan tilpasses nye trusler).

💬 Konklusion: ESP32 + LoRa mesh er en lovende løsning til detektion af fremmede enheder, men kræver omhyggelig planlægning (teknisk, juridisk og etisk) for at blive implementeret i praksis. Et pilotprojekt i et begrænset område (f.eks. en lufthavn) ville være det næste logiske skridt.