DIY: DJI Pocket 4 Controller?

[ruessel]

Hier ein ESP32-C6 Test-Code um zu versuchen die DJI Pocket 4 zu hacken, an der DJI Action 6 / 360 läuft es, benutzt das DJI R‑SDK‑Protokoll:

Code: Alles auswählen

#include <NimBLEDevice.h>

static NimBLEAdvertisedDevice* djiDevice = nullptr;
static NimBLEClient* client = nullptr;

static NimBLEUUID serviceUUID("0000fee7-0000-1000-8000-00805f9b34fb");
static NimBLEUUID charUUID("000036f5-0000-1000-8000-00805f9b34fb");

NimBLECharacteristic* controlChar = nullptr;

uint8_t recordToggleFrame[] = {
  0x55, 0x0A, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63
};

class AdvertisedDeviceCallbacks : public NimBLEAdvertisedDeviceCallbacks {
  void onResult(NimBLEAdvertisedDevice* dev) override {
    if (dev->getName().find("DJI") != std::string::npos) {
      Serial.println("DJI Gerät gefunden!");
      djiDevice = dev;
      NimBLEDevice::getScan()->stop();
    }
  }
};

void setup() {
  Serial.begin(115200);
  NimBLEDevice::init("ESP32-DJI-Test");

  NimBLEScan* scan = NimBLEDevice::getScan();
  scan->setAdvertisedDeviceCallbacks(new AdvertisedDeviceCallbacks());
  scan->setActiveScan(true);
  scan->start(10, false);
}

void loop() {
  if (djiDevice && !client) {
    Serial.println("Verbinde zu DJI Gerät...");
    client = NimBLEDevice::createClient();

    if (client->connect(djiDevice)) {
      Serial.println("Verbunden!");

      NimBLEService* service = client->getService(serviceUUID);
      if (!service) {
        Serial.println("Service nicht gefunden!");
        return;
      }

      controlChar = service->getCharacteristic(charUUID);
      if (!controlChar) {
        Serial.println("Characteristic nicht gefunden!");
        return;
      }

      Serial.println("Sende Record Toggle Frame...");
      controlChar->writeValue(recordToggleFrame, sizeof(recordToggleFrame));

      Serial.println("Warten auf Antwort...");
    }
  }

  delay(2000);
}

Ich kann es nicht testen, da die Kamera noch nicht vor Ort ist. Diese Software versucht Kontakt zur Kamera zu bekommen:

- aktiviert BLE

- sucht nach DJI‑Geräten

- verbindet sich automatisch

- sendet einen Record‑Toggle‑Frame (Start/Stop)

- loggt jede Antwort der Pocket 4 im seriellen Monitor

Hinweis: Das ist ein Testprogramm, kein fertiger Controller.
Es prüft nur, ob die Pocket 4 das Protokoll versteht.

Damit könnte man einen kleinen drahtlosen Controller für die Kamera basteln, den es anscheinend nicht auf dem Markt gibt. Muss ja nicht immer nur das Smartphone mit App sein ;-)

Aber: Gilt dieses Protokoll auch für die DJI Pocket 4?
Hier wird es schwierig:

- DJI veröffentlicht kein offizielles SDK für die Pocket‑Serie.
- Es gibt keine Dokumentation, dass die Pocket 4 das gleiche R‑SDK‑Protokoll nutzt wie Osmo Action 6 oder Osmo 360.
- Die Pocket 4 lässt sich zwar per Smartphone steuern, aber DJI kapselt diese Kommunikation in der DJI Mimo App.

Es wird nie langweilig, sobald meine Pocket 4 da ist (zum WE) teste ich natürlich ob es klappt. Aber selbst wenn es klappt, wird die Entwicklung einer sinnvollen Anwendung wie z.B. Radargesteuerter Auslöser etc. noch etwas dauern, es liegen noch andere Projekte hier an, diese Bastelarbeit ist zwar spannend, muss aber trotzdem etwas warten ;-)

[ruessel]

Heute soll meine Pocket 4 geliefert werden und ich musste feststellen, ich habe nur noch freie ESP 32D hier liegen, sind günstige nachbauten des ESP32 WROOM Link: https://www.ebay.de/itm/317665795063. Daher wurde das Sketch nochmal für diesen Chip überarbeitet, kleinere Fehler wurden beseitigt. Ich benutze die "BLE" Bibliothek von 2017 Neil Kolban, nur diese funktioniert hier. Link dazu: https://github.com/espressif/arduino-esp32 zur Zeit die Version 3.3.8

Der Sketch läuft einwandfrei, habe es schon in einen Chip geladen - nur die Kamera zum Testen fehlt. Das Skript ist nicht nur für die Pocket, sondern für alle DJI Produkte die sich verbinden können. Damit hat man(n) einen Anhalt ob sich freie Entwicklungen für das Produkt überhaupt lohnen oder DJI legt ihre Protokolle in Zukunft frei offen. ;-)

Code: Alles auswählen

// DJI Kontaktsoftwaretest Ruesseltechnik V23.04.2026
// fuer ESP32 WROOM
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEAdvertisedDevice.h>

// DJI Pocket 4 BLE UUIDs
static BLEUUID djiServiceUUID("0000fdc0-0000-1000-8000-00805f9b34fb");
static BLEUUID djiControlCharUUID("0000fdc1-0000-1000-8000-00805f9b34fb");

BLEClient* client = nullptr;
BLERemoteCharacteristic* controlChar = nullptr;

BLEAdvertisedDevice* foundDev = nullptr;
bool connected = false;
bool scanning = false;

// Statusanzeige
unsigned long lastStatus = 0;
int scanSeconds = 0;
int dotCount = 0;

// Frame zum Start/Stop der Aufnahme
uint8_t recordToggleFrame[] = {0x03, 0x01, 0x00, 0x00};

class DJIAdvertisedDeviceCallbacks : public BLEAdvertisedDeviceCallbacks {
  void onResult(BLEAdvertisedDevice advertisedDevice) override {

    if (advertisedDevice.isAdvertisingService(djiServiceUUID)) {
      Serial.println("DJI Pocket 4 gefunden!");

      foundDev = new BLEAdvertisedDevice(advertisedDevice);
      scanning = false;

      BLEDevice::getScan()->stop();
    }
  }
};

void startScan() {
  Serial.println("Starte Scan...");
  scanning = true;
  scanSeconds = 0;
  dotCount = 0;

  BLEScan* scan = BLEDevice::getScan();
  scan->setAdvertisedDeviceCallbacks(new DJIAdvertisedDeviceCallbacks());
  scan->setActiveScan(true);
  scan->start(3, false);
}

bool connectToPocket() {
  if (!foundDev) return false;

  Serial.println("Verbinde zur DJI Pocket 4...");

  client = BLEDevice::createClient();

  if (!client->connect(foundDev)) {
    Serial.println("Verbindung fehlgeschlagen.");
    return false;
  }

  Serial.println("Verbunden!");

  BLERemoteService* service = client->getService(djiServiceUUID);
  if (!service) {
    Serial.println("Service nicht gefunden!");
    return false;
  }

  controlChar = service->getCharacteristic(djiControlCharUUID);
  if (!controlChar) {
    Serial.println("Control Characteristic nicht gefunden!");
    return false;
  }

  Serial.println("Control Characteristic bereit.");
  connected = true;
  return true;
}

void setup() {
  Serial.begin(115200);
  Serial.println("DJI Pocket 4 Auto-Scan/Auto-Reconnect gestartet...");

  BLEDevice::init("");

  startScan();
}

void loop() {

  // 1) Wenn nicht verbunden → Status anzeigen
  if (!connected) {

    // Jede Sekunde Status ausgeben
    if (millis() - lastStatus > 1000) {
      lastStatus = millis();
      scanSeconds++;

      // Punkt-Animation
      dotCount = (dotCount + 1) % 4;
      String dots = "";
      for (int i = 0; i < dotCount; i++) dots += ".";

      Serial.print("Pocket 4 suchen ");
      Serial.print(dots);
      Serial.print("  ");
      Serial.print(scanSeconds);
      Serial.println("s");
    }

    // Falls Scan fertig, aber kein Gerät → erneut scannen
    if (!scanning && !foundDev) {
      startScan();
      return;
    }

    // Gerät gefunden → verbinden
    if (foundDev && !connected) {
      if (connectToPocket()) {
        Serial.println("Bereit für Befehle.");
      } else {
        Serial.println("Neuer Versuch in 2 Sekunden...");
        delay(2000);
        foundDev = nullptr;
        startScan();
      }
      return;
    }

    return;
  }

  // 2) Wenn verbunden → Toggle senden
  if (connected && controlChar) {
    Serial.println("Sende Aufnahme-Toggle...");

    bool ok = controlChar->writeValue(recordToggleFrame, sizeof(recordToggleFrame), false);

    if (ok) Serial.println("Frame gesendet.");
    else    Serial.println("Fehler beim Senden.");

    delay(2000);

    if (controlChar->canRead()) {
      String resp = controlChar->readValue();
      Serial.print("Antwort: ");
      Serial.println(resp);
    }

    delay(3000);
  }

  // 3) Verbindung prüfen
  if (client && !client->isConnected()) {
    Serial.println("Verbindung verloren! Starte Reconnect...");
    connected = false;
    controlChar = nullptr;
    foundDev = nullptr;
    startScan();
  }
}

[ruessel]

Leider kein sofortiger Erfolg! Wäre ja auch zu einfach.

Wichtigste Erkenntnis: Die Pocket 4 sendet NICHT den DJI‑Service FDC0
Ich habe erwartet:

FDC0 → DJI Remote Control Service

FDC1 → Control Characteristic

Aber die Pocket 4 sendet:

👉Service UUID: FFF0 (Generic BLE Vendor Service)
Das bedeutet:

❗ Die Pocket 4 nutzt NICHT das gleiche BLE‑Protokoll wie die Pocket 2 oder Osmo Action.
❗ Sie sendet nur einen generischen Vendor‑Service (FFF0), kein DJI‑Remote‑Control‑Service.

Ich gebe aber noch nicht auf!

Dahinter bin ich mit diesem Programm gekommen, ein Schnüffler für alle Geräte in der Umgebung!
Die Osmo Pocket 4 meldet sich auch sofort wie folgt:

---- Gerät gefunden ----
Adresse: 4c:43:f6:17:3b:60
Name: OsmoPocket4-3B5F
RSSI: -34
RAW:
Name: OsmoPocket4-3B5F, Address: xx:xx:xx:xx:xx:xx, manufacturer data: aa08210000dxxxxxxxxx000000000, serviceUUID: 0000fff0-0000-1000-8000-00xxxxxxxxxxx, rssi: -34 (genaue Daten mit x hier im Forum anonym gemacht)
------------------------

Hier der Code für meinen SUPER-RAW-BLE-DEBUG-SCANNER ;-)
Die Pocket in der Nähe vom ESP32 legen, die Empfindlichkeit des Scanners habe ich stark gedämpft, ich will ja nicht noch das Bügeleisen der Nachbarn scannen, sind so schon genug Geräte die sich hier im Haus melden.

Code: Alles auswählen

// SUPER-RAW-BLE-DEBUG-SCANNER für ESP32
// Er scannt alles was in der Umgebung ist; Ruesseltechnik 23.04.2026

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEAdvertisedDevice.h>

unsigned long lastStatus = 0;
int scanSeconds = 0;
int packetCounter = 0;

class RawCallbacks : public BLEAdvertisedDeviceCallbacks {
  void onResult(BLEAdvertisedDevice d) override {

    packetCounter++;

    // Option A: Nur jedes 10. Paket anzeigen
    if (packetCounter % 10 != 0) return;

    // Option B: Nur starke Signale anzeigen
    if (d.getRSSI() < -85) return;

    Serial.println("---- Gerät gefunden ----");

    Serial.print("Adresse: ");
    Serial.println(d.getAddress().toString().c_str());

    Serial.print("Name: ");
    Serial.println(d.getName().c_str());

    Serial.print("RSSI: ");
    Serial.println(d.getRSSI());

    Serial.println("RAW:");
    Serial.println(d.toString().c_str());

    Serial.println("------------------------\n");
  }
};

void setup() {
  Serial.begin(115200);
  delay(2000);
  Serial.println("RAW BLE Debug Scanner gestartet!");

  BLEDevice::init("");

  BLEScan* scan = BLEDevice::getScan();
  scan->setAdvertisedDeviceCallbacks(new RawCallbacks());
  scan->setActiveScan(true);   // wichtig: holt auch Scan-Response
  scan->setInterval(100);
  scan->setWindow(99);
}

void loop() {

  // Jede Sekunde Status anzeigen
  if (millis() - lastStatus > 1000) {
    lastStatus = millis();
    scanSeconds++;
    Serial.print("Scanne... ");
    Serial.print(scanSeconds);
    Serial.println("s");
  }

  BLEDevice::getScan()->start(3, false);
  delay(200);
}

[ruessel]

Jackpot.

Jetzt geht es ins eingemachte. Ich musste noch eine Software erstellen, die die Pocket 4 veranlasst sich zu melden und verrät was sie an Eingaben erwartet. Software dazu unten.

Erkenntnis:
DJI hat das Protokoll geändert das die Pocket 2, Osmo Action, Ronin etc. nutzen:

FDC0 / FDC1 (DJI Remote Control Service)

Die Pocket 4 nutzt:

FFF0 / FFF3 / FFF4 / FFF5

Das bedeutet:

👉 Der alte DJI‑Remote‑Control‑Code funktioniert nicht.
👉 Wir müssen das Protokoll der Pocket 4 reverse‑engineeren.

Die Pocket 4 zeigt drei Services:
(1) Generic Access (0x1800)
Standard‑BLE‑Service, nichts DJI‑spezifisches.

0x2A00 = Device Name
→ Wert: OsmoPocket4-5879
→ READ + WRITE (hier könnte man den Namen ändern)

(2) Generic Attribute (0x1801)
Standard‑Service für Service‑Änderungen. Firmware?
Nicht relevant für Steuerung.

(3) Vendor‑Service FFF0 (wichtig!)
Das ist der einzige DJI‑spezifische Service, den die Pocket 4 freigibt. Service UUID: FFF0

Nächster Schritt: Wir müssen herausfinden, welche Characteristic reagiert
Dazu brauchen wir einen Command‑Tester, der:

- sich verbindet

- FFF3, FFF4 und FFF5 einzeln testet

- kleine Test‑Frames sendet

- schaut, ob die Pocket 4 antwortet

- schaut, ob NOTIFY‑Events kommen

Damit finden wir heraus:

- welche Characteristic Befehle annimmt

- welches Format DJI erwartet

- ob Start/Stop möglich ist

- ob die Kamera eine Session‑ID oder ein Pairing‑Token braucht

das alles dauert nun ein wenig, auch ist es genug für heute...... wir sind jetzt mal sehr optimistisch und damit wirklich kurz davor, die Pocket 4 vollständig zu kontrollieren!

Code: Alles auswählen

// SERVICES DER POCKET 4 auslesen.
// Ruesseltechnik 23.04.2026

#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEScan.h>
#include <BLEClient.h>

static BLEAddress pocketAddr("4c:43:f6:17:3b:60");  // Deine Pocket 4 MAC hier einsetzen, mein SUPER-RAW-BLE-DEBUG-SCANNER Sketch dazu benutzen!!
BLEClient* client;

void printHexFromString(const String &data) {
  Serial.print("    Value (hex): ");
  for (size_t i = 0; i < data.length(); i++) {
    char buf[4];
    sprintf(buf, "%02X ", (uint8_t)data[i]);
    Serial.print(buf);
  }
  Serial.println();
}

void exploreServices(BLEClient* client) {
  auto services = client->getServices();

  Serial.println("\n==============================");
  Serial.println("   SERVICES DER POCKET 4");
  Serial.println("==============================");

  for (auto const& entry : *services) {
    BLERemoteService* service = entry.second;

    Serial.print("\nService UUID: ");
    Serial.println(service->getUUID().toString().c_str());

    auto chars = service->getCharacteristics();

    for (auto const& centry : *chars) {
      BLERemoteCharacteristic* ch = centry.second;

      Serial.print("  Characteristic UUID: ");
      Serial.println(ch->getUUID().toString().c_str());

      Serial.print("    Properties: ");
      if (ch->canRead()) Serial.print("READ ");
      if (ch->canWrite()) Serial.print("WRITE ");
      if (ch->canWriteNoResponse()) Serial.print("WRITE_NR ");
      if (ch->canNotify()) Serial.print("NOTIFY ");
      if (ch->canIndicate()) Serial.print("INDICATE ");
      Serial.println();

      // Wert auslesen, falls möglich
      if (ch->canRead()) {
        String val = ch->readValue();  
        printHexFromString(val);
      }
    }
  }
}

void setup() {
  Serial.begin(115200);
  delay(2000);
  Serial.println("Pocket 4 BLE Service Explorer gestartet!");

  BLEDevice::init("");

  client = BLEDevice::createClient();
}

void loop() {

  if (!client->isConnected()) {
    Serial.println("Verbinde mit Pocket 4...");

    if (client->connect(pocketAddr)) {
      Serial.println("Verbunden!");
      exploreServices(client);
    } else {
      Serial.println("Verbindung fehlgeschlagen. Neuer Versuch in 3s...");
      delay(3000);
      return;
    }
  }

  Serial.println("\nFertig. Explorer läuft nicht erneut.");
  while (true) delay(1000);
}

[ruessel]

Zu früh gefreut und zu optimistisch gewesen. Habe mir die halbe Nacht damit um die Ohren gehauen und diverse Versuche unternommen die Pocket 4 zu steuern. Deshalb hier ein kurzes Innehalten und alle Erkenntnisse zusammen fassen.

Kurzfassung zuerst: Die Pocket 4 hat meine Befehle nicht angenommen, weil der BLE‑Kontrollkanal ohne einen gültigen, dynamisch erzeugten Session‑Handshake gesperrt bleibt.
Alles, was ich gesendet habe, kam an – aber die Kamera hat es bewusst ignoriert.

Langfassung:
1) Die Pocket 4 akzeptiert BLE‑Verbindung – aber nicht die Steuerung
Ich konnte:
- verbinden
- NOTIFY aktivieren
- auf FFF3 / FFF4 / FFF5 schreiben

Das heißt: die Hardware‑Ebene war korrekt.
Die Kamera blockiert aber die logische Steuerungsebene.

2. DJI verwendet bei der Pocket 4 ein neues, verschlüsseltes Protokoll
Frühere DJI‑Geräte (Pocket 2, OM‑Gimbals, Action 2/3) nutzten:

- unverschlüsselte FDC0/FDC1‑Services
- einfache Handshake‑Frames (bekannt aus Reverse‑Engineering)

Die Pocket 4 nutzt:

- FFF0‑Servicefamilie
- verschlüsselte Session‑Authentifizierung
- dynamische Challenge‑Response‑Frames, die pro Verbindung neu generiert werden

Ohne diese Challenge‑Response bleibt der Kanal read/write‑fähig, aber inaktiv.

3. Alle gesendeten Befehle wurden verworfen
ich habe:
- Test‑Frames gesendet
- alte DJI‑Handshake‑Frames getestet
- NOTIFY aktiviert

Ergebnis:
- 0 Antworten
- 0 Notify‑Frames
- 0 Fehlercodes

Das ist typisch für ein locked control channel Verhalten:
Die Kamera nimmt Frames entgegen, prüft sie, erkennt „kein gültiger Session‑Key“ und verwirft sie still.

4. Der Auto‑Handshake‑Tester (Software veröffentliche ich nicht) hat bestätigt: kein bekannter Handshake funktioniert
ich habe alle bekannten DJI‑Handshake‑Varianten durchprobiert.
Keiner wurde akzeptiert, also ist klar hier ein neues, unbekanntes Protokoll.

Damit ist auch klar:
DJI hat das Protokoll komplett geändert und verschlüsselt.

5. Warum sendet die Pocket 4 nicht einmal Status‑Notify?
Weil Notify erst nach erfolgreichem Session‑Handshake aktiviert wird.
Ich konnte zwar NOTIFY technisch aktivieren, aber die Kamera sendet erst Daten, wenn der Session‑Key stimmt.

Jetzt wäre eigentlich der Punkt sich von den DJI Ingenieuren geschlagen zu geben und das Projekt zu beenden. Aber eine Idee habe ich noch: Den Funkverkehr zwischen der Mimo App und der Pocket zu belauschen! Es brauchen ja nur die verschlüsselten Daten als Muster gesendet werden - den Inhalt muss ich nicht verstehen. (sehr stark vereinfacht, da die Muster jedesmal wechseln, Record z.B. hat jedesmal wenn er gedrückt wird ein anderes Muster - Mustererkennung ist dann KI arbeit)

Um jetzt weiter zu kommen, reicht kein üblicher ESP32 aus um das verschlüsselte Signal in der gesamten Tiefe zu analysieren, dazu braucht es einen Spezial Chip der echtes "Sniffing" beherrscht. Habe damit noch nie gearbeitet aber muss ja nicht so bleiben. Der Spezialchip ist bestellt, in einer Woche sollte er da sein und dann geht hoffentlich die Sonne auf...... und die Pocket 4 denkt, sie redet mit der Mimo app.