Balise de signalement électronique DIY

La réglementation pour avoir le droit de faire voler un drone sur le territoire français est comment dire 'restrictive'...
De 'je fais ce que je veux' on est passé à 'tu fait ce que l'autorité accepte'.

La loi: https://www.legifrance.gouv.fr/affichTexte.do?cidTexte=JORFTEXT000033293745&dateTexte&categorieLien=id

Je ne vais pas tout reprendre, d'autre l'on fait très bien:

https://www.djiphantom-forum.com/t33315-tout-ce-que-vous-devez-savoir-faire-si-votre-drone-depasse-800g

https://www.helicomicro.com/2020/06/04/signalement-electronique-a-distance-letat-des-lieux-dji-les-balises/

Et donc en conclusion: Mon drone fait plus de 800g, il est donc enregistré sur alphaTango, j'ai fait la formation en ligne, certifiée par un QCM et la délivrance d'une attestation.
A partir du premier novembre 2020, je n'aurai le droit de voler que si mon appareil émet une trame wifi contenant son identification et sa position.

Les drones récents vont être mis a jour au niveau du firmware pour 'naturellement' émettre ce signal, sur mon P3A (phantom 3 Advanced) ce ne sera évidement pas le cas (même si le matériel en est capable). Il existe déjà des balisent en vente (de l'ordre de 120 €) mais heureusement le DIY est là  

On trouve ici: https://discuss.ardupilot.org/t/open-source-french-drone-identification/56904 la description d'une balise DIY

Je vais donc faire ma propre balise de signalement électronique en utilisant un module ESP-01 qui contient toute l'électronique nécessaire (un microcontroleur et une interface wifi avec l'antenne)
J'ai pris celui-ci sur ali: (pour info)

https://fr.aliexpress.com/item/32739060009.html?spm=a2g0s.9042311.0.0.27426c37Hj1WNF



Il faut aussi une interface de programmation pour l'ESP01 qui ne dispose pas du connecteur USB pour le faire 'in situ'
J'ai pris celle-ci sur ali (pour info)



On trouve aussi l'ESP01S et le programmateur ensemble:
ESP01S + prog



Pour le module GPS, j'ai pris celui-ci:
https://fr.aliexpress.com/item/4001084058040.html?spm=a2g0s.9042311.0.0.27426c37wXQ3fe



Et on arrive bien au prix de 10€  

Il faut transférer le programme suivant dans l'ESP01S

Noter qu'un cavalier doit être ajouté sur le programmateur pour l'ESP01... (sinon il ne se programme pas)
Des infos complètes ici: prog ESP01
J'ai fait ceci:



J'ai ajouté quelques conseils au début du programme qui doit être transféré vers la carte 'generic esp8266 Module'

Mettre votre identifiant à la place de 000000000000000000UAS-FR-19*** (Votre numéro obtenu sur alpha tango conviens très bien), les 3 premiers zéros correspondent au trinigramme 000 qui est ausi acceptable pour les balises DIY. Vérifier bien que vous avez trente caractères
ainsi qu'un ssid qui vous plait, c'est le nom du réseau ouvert wifi créé (j'ai mis P3A)

Il faudra aussi ajouter dans les bibliothèque arduino la bibliothèque de gestion du GPS:
Gestion du GPS: https://github.com/mikalhart/TinyGPSPlus/releases

(testé sur une carte ESP01S avec un module GPS externe)

Le code à placer dans l'esp est dispo ici:

https://github.com/f5soh/balise_esp32/tree/droneID_FR_testing

Mon code est téléchargeable ici: A placer dans un dossier arduino

Il faut placer dans l'IDE le premier code et il faut aussi ajouter le code 'droneID_FR.h' dans l'IDE en créant un onglet supplémentaire (petite flèche descendante en faut a droite).

Il y a plusieurs solutions pour vérifier si la balise émet bien la trame:
Avec un PC (non testé): https://www.photo18.fr/tutos/recevoir-une-balise-signalement-drone/

Avec une carte TT-GO T-BEAM:
J'ai programmé une carte TT-GO T-BEAM V1.0 pour pouvoir recevoir et décoder la trame pour vérifier sa cohérence

Le programme 'décode balise pour esp32-BT' avec sortie bluetooth
https://github.com/dev-fred/Decode_balise_ESP32
Testé sur une carte TT-GO T-BEAM V1.0 avec succès
Cela permet de réaliser une carte autonome de lecture des balises de signalement électronique permettant de vérifier si la balise émet bien les trames et éventuellement de localiser un drone crashé si la balise émet toujours.

Code:


//     https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
//      (à placer dans fichier, préférences, url de gestionnaire de cartes supplémentaires)
#include "freertos/FreeRTOS.h"
#include "esp_wifi.h"
#include "esp_wifi_types.h"
#include "esp_system.h"
#include "esp_event.h"
#include "esp_event_loop.h"
#include "nvs_flash.h"
#include "driver/gpio.h"
#include "BluetoothSerial.h"


BluetoothSerial BT; //Object for Bluetooth
char buff[1][256];

#define LED_GPIO_PIN                     5

/**
  * Enumeration des types de données à envoyer
*/
enum DATA_TYPE: uint8_t {
  RESERVED = 0,
  PROTOCOL_VERSION = 1,
  ID_FR = 2,
  ID_ANSI_CTA = 3,
  LATITUDE = 4,        // In WS84 in degree * 1e5
  LONGITUDE = 5,       // In WS84 in degree * 1e5
  ALTITUDE = 6,        // In MSL in m
  HEIGTH = 7,          // From Home in m
  HOME_LATITUDE = 8,   // In WS84 in degree * 1e5
  HOME_LONGITUDE = 9,  // In WS84 in degree * 1e5
  GROUND_SPEED = 10,   // In m/s
  HEADING = 11,        // Heading in degree from north 0 to 359.
  NOT_DEFINED_END = 12,
};

/**
  * Tableau TLV (TYPE, LENGTH, VALUE) avec les tailles attendu des différents type données.
***/
static constexpr uint8_t TLV_LENGTH[] {
  0,  // [DATA_TYPE::RESERVED]
  1,  // [DATA_TYPE::PROTOCOL_VERSION]
  30, // [DATA_TYPE::ID_FR]
  0,  // [DATA_TYPE::ID_ANSI_CTA]
  4,  // [DATA_TYPE::LATITUDE]
  4,  // [DATA_TYPE::LONGITUDE]
  2,  // [DATA_TYPE::ALTITUDE]
  2,  // [DATA_TYPE::HEIGTH]
  4,  // [DATA_TYPE::HOME_LATITUDE]
  4,  // [DATA_TYPE::HOME_LONGITUDE]
  1,  // [DATA_TYPE::GROUND_SPEED]
  1,  // [DATA_TYPE::HEADING]
};


typedef struct {
  unsigned frame_ctrl:16;
  unsigned duration_id:16;
  uint8_t addr1[6]; /* receiver address */
  uint8_t addr2[6]; /* sender address */
  uint8_t addr3[6]; /* filtering address */
  unsigned sequence_ctrl:16;
  uint8_t addr4[6]; /* optional */
} wifi_ieee80211_mac_hdr_t;


typedef struct  {
  int16_t fctl;
  int16_t duration;
  uint8_t da;
  uint8_t sa;
  uint8_t bssid;
  int16_t seqctl;
  unsigned char payload[];
} __attribute__((packed)) WifiMgmtHdr;

typedef struct {
  WifiMgmtHdr hdr;
  uint8_t payload[0];
} wifi_ieee80211_packet_t;

static esp_err_t event_handler(void *ctx, system_event_t *event);
static void wifi_sniffer_init(void);
static void wifi_sniffer_set_channel(uint8_t channel);
static const char *wifi_sniffer_packet_type2str(wifi_promiscuous_pkt_type_t type);
static void wifi_sniffer_packet_handler(void *buff, wifi_promiscuous_pkt_type_t type);

esp_err_t event_handler(void *ctx, system_event_t *event)
{
  return ESP_OK;
}

void wifi_sniffer_init(void)
{
  nvs_flash_init();
  tcpip_adapter_init();
  ESP_ERROR_CHECK( esp_event_loop_init(event_handler, NULL) );
  wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
  ESP_ERROR_CHECK( esp_wifi_init(&cfg) );
  ESP_ERROR_CHECK( esp_wifi_set_storage(WIFI_STORAGE_RAM) );
  ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_NULL) );
  ESP_ERROR_CHECK( esp_wifi_start() );
  esp_wifi_set_promiscuous(true);
  esp_wifi_set_promiscuous_rx_cb(&beaconCallback);
}

void wifi_sniffer_set_channel(uint8_t channel)
{
  esp_wifi_set_channel(channel, WIFI_SECOND_CHAN_NONE);
}

// Function to extract MAC addr from a packet at given offset
void getMAC(char *addr, uint8_t* data, uint16_t offset) {
  sprintf(addr, "%02x:%02x:%02x:%02x:%02x:%02x", data[offset+0], data[offset+1], data[offset+2], data[offset+3], data[offset+4], data[offset+5]);
}

static void printDataSpan(uint16_t start, int len, uint16_t size, uint8_t* data) {
  for(uint16_t i = start; i < len && i < start+size; i++) {
    Serial.write(data[i]);
    BT.write(data[i]);
  }
}

static void printCoordinates(uint16_t start, int len, uint16_t size, uint8_t* data) {
  uint8_t count = size-1;
  int data_value = 0;
  //Serial.print(" data_value="); Serial.print(data_value); Serial.print(" neg=");
  bool neg_number = data[start] > 0x7F;
  //Serial.print(neg_number);Serial.print(" ");
  
  for(uint16_t i = start; i < len && i < start+size; i++) {
    //Serial.print(count); Serial.print("-");  
    data_value +=  (data[i]) << (8 * count);
    count--;
  }
  
  if(neg_number) {
    data_value = (0xFFFFFFFF & ~data_value) + 1;
    data_value *= -1;
  }
  
  Serial.print(double(data_value) * 0.00001 , 5);
  BT.print(double(data_value) * 0.00001 , 5);
}

static void printAltitude(uint16_t start, int len, uint16_t size, uint8_t* data) {
  uint8_t count = size-1;
  int data_value = 0;
  bool neg_number = data[start] > 0x7F;
  //Serial.print(neg_number);Serial.print(" ");
  
  for(uint16_t i = start; i < len && i < start+size; i++) {
    //Serial.print(count); Serial.print("-");  
    data_value +=  (data[i]) << (8 * count);
    count--;
  }
  
  if(neg_number) {
    data_value = (0xFFFF & ~data_value) + 1;
    data_value *= -1;
  }
  
  Serial.print(data_value);
  BT.print(data_value);
}

void beaconCallback(void* buf, wifi_promiscuous_pkt_type_t type)
{
  wifi_promiscuous_pkt_t *snifferPacket = (wifi_promiscuous_pkt_t*)buf;
  WifiMgmtHdr *frameControl = (WifiMgmtHdr*)snifferPacket->payload;
  wifi_pkt_rx_ctrl_t ctrl = (wifi_pkt_rx_ctrl_t)snifferPacket->rx_ctrl;
  int len = snifferPacket->rx_ctrl.sig_len;
  uint8_t SSID_length = (int)snifferPacket->payload[40];
  uint8_t offset_OUI = 42+SSID_length;
  const uint8_t FRAME_OUI[3] = {0x6A, 0x5C, 0x35};
  
  //Filter OUI from 6A:5C:35
  if(snifferPacket->payload[offset_OUI+1] != FRAME_OUI[0] && snifferPacket->payload[offset_OUI+2] != FRAME_OUI[1] && snifferPacket->payload[offset_OUI+3] != FRAME_OUI[2])
  return;
  
  len -= 4;
  int fctl = ntohs(frameControl->fctl);
  const wifi_ieee80211_packet_t *ipkt = (wifi_ieee80211_packet_t *)snifferPacket->payload;
  const WifiMgmtHdr *hdr = &ipkt->hdr;
  
  // If we dont the buffer size is not 0, don't write or else we get CORRUPT_HEAP
  if (snifferPacket->payload[0] == 0x80)
  {
    Serial.print("len=");Serial.print(len,DEC);
    // ID balise
    snprintf(buff[0], sizeof(buff[0])," ID: ");
    BT.print(buff[0]);Serial.print(buff[0]);  printDataSpan(offset_OUI+4+6, len, TLV_LENGTH[ID_FR] , snifferPacket->payload);
    uint16_t offset = offset_OUI+4+6+TLV_LENGTH[ID_FR]+2; // +2 : Type + Length
    delay(400);
    // Latitude
    snprintf(buff[0], sizeof(buff[0])," LAT: ");
    BT.print(buff[0]);Serial.print(" LAT: "); printCoordinates(offset, len, TLV_LENGTH[LATITUDE] , snifferPacket->payload);
    offset += TLV_LENGTH[LATITUDE]+2;
    delay(400);
    // Longitude
    snprintf(buff[0], sizeof(buff[0])," LON: ");
    BT.print(buff[0]);Serial.print(" LON: "); printCoordinates(offset, len, TLV_LENGTH[LONGITUDE] , snifferPacket->payload);
    offset += TLV_LENGTH[LONGITUDE]+2;
    delay(400);
    //Altitude msl
    snprintf(buff[0], sizeof(buff[0])," ALT ABS: ");
    BT.print(buff[0]);Serial.print(" ALT ABS: "); printAltitude(offset, len, TLV_LENGTH[ALTITUDE] , snifferPacket->payload);
    offset += TLV_LENGTH[ALTITUDE]+2;
    delay(400);
    //home altitude
    snprintf(buff[0], sizeof(buff[0])," HAUTEUR: ");
    BT.print(buff[0]);Serial.print(" HAUTEUR: "); printAltitude(offset, len, TLV_LENGTH[HEIGTH] , snifferPacket->payload);
    offset += TLV_LENGTH[HEIGTH]+2;
    delay(400);
    //home latitude
    snprintf(buff[0], sizeof(buff[0])," LAT DEP: ");
    BT.print(buff[0]);Serial.print(" LAT DEP: "); printCoordinates(offset, len, TLV_LENGTH[HOME_LATITUDE] , snifferPacket->payload);
    offset += TLV_LENGTH[HOME_LATITUDE]+2;
    delay(400);
    //home longitude
    snprintf(buff[0], sizeof(buff[0])," LON DEP ");
    BT.print(buff[0]);Serial.print(" LON DEP: "); printCoordinates(offset, len, TLV_LENGTH[HOME_LONGITUDE] , snifferPacket->payload);
    offset += TLV_LENGTH[HOME_LATITUDE]+2;
    delay(400);
    //ground speed
    snprintf(buff[0], sizeof(buff[0])," VITESSE HOR: ");
    BT.print(buff[0]);Serial.print(" VITESSE HOR: "); printAltitude(offset, len, TLV_LENGTH[GROUND_SPEED] , snifferPacket->payload);
    offset += TLV_LENGTH[GROUND_SPEED]+2;
    delay(400);
    //heading
    snprintf(buff[0], sizeof(buff[0])," DIR: ");
    BT.print(buff[0]);Serial.print(" DIR: "); printAltitude(offset, len, TLV_LENGTH[HEADING] , snifferPacket->payload);
    Serial.println();
    BT.println();
    delay(400);
  }
}

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin 5 as an output.
  Serial.begin(115200);
  delay(10);
  BT.begin("Decode_balise");
  delay(1000);
  wifi_sniffer_init();
  wifi_sniffer_set_channel(6);
  pinMode(LED_GPIO_PIN, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  delay(1000); // wait for a second
  if (digitalRead(LED_GPIO_PIN) == LOW)
  digitalWrite(LED_GPIO_PIN, HIGH);
  else
  digitalWrite(LED_GPIO_PIN, LOW);
}

Affichage sur le smartphone:

Intégration de la balise sur un drone phantom 3 Advanced:

J'ai choisi d'alimenter la balise par le drone en profitant de son ouverture (pour renforcer les zones de fixation des moteurs qui fendillaient).
Sur la carte principale il y a 2 convertisseurs à découpage qui fournissent du 3,3V et du 5V, les convertisseurs utilisés pouvant fournir jusqu’à 5 A, 100 mA de plus sur le 3,3 V ne devrait pas poser un problème.
J'ai récupéré le 0V et le 3,3V sur 2 plots de test:


J'ai essayé de récupérer la trame du gps intégré au drone mais le format est du binaire et pas une trame nmea... donc j'ai installé un module gps supplémentaire
Le module est juste à coté du gps principal et tient en place par la feuille de blindage autocollante, ça devrait assurer une bonne réception.

La carte ESP01 va ensuite être installé de manière à ce qu'elle soit facile à reprogrammer si nécessaire, pour cela elle va être installée à l'extérieur du drone
J'ai utilisé un shield pour ESP01 destiné normalement à l'enficher sur une carte prototype:

Celui ci est collé à l'araldite rapide contre le capot:

Evidemment, des trous ont été réalisé avant le collage

permettant d'insérer la carte 'à l'extérieur'

Le câblage à réaliser est le suivant:


Il faudra faire une liaison sur l'ESP01 entre VCC et CH_PD pour alimenter le GPS seulement quand le module est enfiché.



La balise sur son programmateur: A noter qu'il faut enlever la liaison externe pour pouvoir la programmer (ce qui n'est pas fait sur la photo)

Le câblage: (rien d'insurmontable !)
Le fil vert c'est le signal du GPS, les gros rouge et marron l'arrivée 3,3V et le 0V, les petits rouge et noir le 3.3V et 0V pour le GPS


La balise en place (il manque la liaison externe qui active le GPS):

Pour avoir un identifiant légal, j'ai demandé à la DGAC l'attribution d'un "trinigramme" composé de 3 lettres comme son non l'indique, j'ai reçu celui-ci par mail une quinzaine de jours après la demande.
Il a été ainsi possible de saisir un identifiant légal sur AlphaTango. Mon vieux drone de plus de 800g va être ainsi parfaitement en règle avec celles d'identification électronique. Je doute fort que les services de la maréchaussée soit équipés pour lire les identifiants mais au moins cela m'aura permis de découvrir le monde des ESP01 et autres ESP32 ou 8266, très intéressants aussi pour d’autres applications (domotique par exemple).

News: Pour la construction amateur de balise on peux utiliser le trinigramme 000

voir ici: https://frskytaranis.forumactif.org/t11183p175-legislation-equiper-sont-aeronef-d-une-balisea-partir-du-29-decembre-2020#126412

salut !
Merci de ce retour super complet !
Après avoir fais mes balises esp32 pour mon phantom 4 pro , j'attaque les esp01 pour mes racer !
J'ai réussi sans problème à compiler et flashé le module, cependant impossible de se connecté au wifi émit (wifi saturé), d'où ma question.
Peux ont lire les trames beacon sans être connecté au réseau émit ? et as tu eu le même message ? merci d'avance !

On peut voir qu'un réseau à été créé avec un sniffer wifi. Pour décoder la trame faut un récepteur capable de décoder la trame beacon, j'ai utilisé avec succès une carte TT-GO T-BEAM V1.0 qui décodait la trame et la ré-envoyait en Bluetooth que je recevais sur un smartphone avec une appli 'terminal Bluetooth'

oui j'ai vu et bien suivis aussi le projet open source (d'ailleurs ton code est en compilation dans mon esp32 tft lol), c'était juste savoir si il fallait être connecté au wifi ou si il suffisais qu'il émette pour être sniffé en monitoring ?

Les trames beacon sont lues 'a la volée' et ne nécessitent pas de connexion.

re ! alors effectivement j'ai reussi a flash le decode balise BT et les trames de l'esp32 sont lu correctement.
par contre j'ai deux soucis, le decodebalise tft ne fonctionne pas (je n'ai pas d'image a l'écran alors que ce dernier était fonctionnel avant flash) et le l'esp01 emmet bien un point d'accès mais aucunes trames ne sont sniffés, je l'ai test a nue, estce normal (si le branchement gps n'est pas fait) de ne rien voir ? je devrais avoir des trames avec tout à zéro au minimum non ?

Les trames ne sont émises par l'esp01 que si le GPS est connecté et si le fix est fait.

Top ! merci bcp !
Et tu aurais une idée pour le tft de l'esp32 ? des manip a effectué pour afficher ?
Merci d'avance ! et merci pour ta disponibilité et le boulot que tu abat !

De rien, tu m'as fait me rendre compte que l'identifiant de ma balise n'était pas à jour... Je l'ai donc reprogrammé et j'ai du me replonger dans le projet.
En tout cas, tout fonctionne, j'ai bien reçu en Bluetooth sur mon smartphone la trame émise en wifi par le module du drone, reçue et décodée par le module TT Go.
Sinon j'ai vu sur le github qu'il y avait des softs supplémentaires pour afficher la position de la balise sur le smartphone... Perso, je laisse en l'état.

Pour le TFT... Il y a tellement de raisons possibles !

Top ! ^^
Je vais retest le montage que tu propose le tout avec mes bn220 upgrade.
Pour le tft tu pense que ça viendrais du code ? Un petit debug mode pour voir ce qui n'irai pas pourrait il aider ?
J'ai cette version (qui je crois est la même que toi ^^),
https://a.aliexpress.com/_mstWFsv
Tu penses que les librairies ne sont pas les mêmes et que ça ai pus foirer à ce niveau ? Je trouve ça bizarre que la version BT du code fonctionne et non la version tft.
Je me demande si on ne pourrais pas mélanger les deux lol ^^ un tft BT xD

Ma carte qui sert au décodage c'est celle ci (en 868MHz): https://www.banggood.com/fr/search/1609523.html?from=nav

Petit test aujourd'hui d'une version amélioré du logiciel de la balise permettant d'accéder à un serveur web affichant une carte:



La difficulté c'est d'utiliser sur le smartphone le wifi pour se connecter au réseau généré par la balise ET d'avoir les data via la 4G pour que la carte s'affiche...

La seule solution que j'ai réussi à mettre en œuvre (je suis sous android) c'est d'installer l'appli speedify qui permet l'agrégation du wifi et de la 4G. Elle est gratuite jusqu'à 2 gigas transférés mensuellement apparemment. Sans cette appli, il n'y a que le cadre avec les coordonnées GPS qui s'affiche (c'est déjà pas mal !)

Le logiciel à transférer dans la carte ESP01 est ici: https://github.com/dev-fred/GPS_Tracker_ESP8266/tree/main/GPS_Tracker_ESP8266V1_MAP

Il faut changer l'affectation des broches pour un ESP01:
#define GPS_RX_PIN 0 // Brancher le fil Tx du GPS sur GP0
#define GPS_TX_PIN 2 // pas utilisé

Pas mal du tout ça !! Penses tu que c'est faisable de le couplé avec le GPS du quad via betaflight (de recup le signal et le hdop) plutôt que d'y avoir un gps dédier ?

Bon j'ai installé le logiciel avec serveur Web sur mon esp01, tout est bon le serveur est atteint et l'affichage est good (avec l'agrégation de lien).
Par contre je ne comprend pas je ne reçois aucuns sat, mon GPS est bien alimenté et est fonctionnel (testé et validé de manière séparée), j'ai laissé le module alimenté pdt 15mn, rien à faire, même en sniffant avec le décode balise rien n'arrive, aurais tu une idée ? Voici le cablage que j'ai et qui me semble OK.
Soit dis en passant top la maj du tuto ^^

J'ai déclaré ceci:
#define GPS_BAUD_RATE 9600 //
#define GPS_RX_PIN 0       // Brancher le fil Tx du GPS
#define GPS_TX_PIN 2       // pas utilisé


Il me semble que tu as fait comme moi pour le cablage... Tes #define sont bon ? Il faut vérifier à l'oscilloscope que la trame est bien présente sur GP0

A noter que je ne reçois rien en intérieur, le gps ne capte qu'en extérieur.

Remets aussi ton GPS à 9600 Bds...

J'ai mis le baudrate à 115200 dans le code.
#define GPS_BAUD_RATE 115200 //
Ça devrais passer nn ? Je vais faire les test demain ^^
Je n'ai pas d'oscilloscope et n'a aucune idée de comment mesurer ça mdr

Petit test embarqué ce matin le drone a fait le tour du jardin à 30m d'altitude. Voici la trace GPX importée dans osmand:

Bonjour,

suis très admiratif de cette proposition très efficace.
Peut on éviter de mettre un module GPS et relier l'ESP-01 à la telemtry type Mavlink par exemple (sur Pixhawk) qui a déjà toutes les infos?

merci