Je me suis retrouvé à vouloir envoyer des fichiers depuis une carte Arduino vers un ordinateur, sans brancher de fil ni configurer une connexion réseau. Le bluetooth semble être une bonne option.

```
🚧 Il y a sûrement des méthodes moins "bricolage" pour envoyer des fichiers en bluetooth, 
mais j'ai décidé de foncer sans trop faire de recherches.
```

# Petite introduction au BLE GATT

Le BLE (Bluetooth Low Energy), c'est comme le bluetooth mais en mieux (?). Peut-être que ça sert pas à la même chose ? Je sais pas trop mais "Low Energy" ça sonne bien donc j'ai choisi de partir là dessus.

Il y a déjà assez de ressources en ligne pour comprendre en quoi ça consiste (comme [ici](https://www.oreilly.com/library/view/getting-started-with/9781491900550/ch04.html), ou [là](https://www.bluetooth.com/bluetooth-resources/intro-to-bluetooth-gap-gatt/), encore par [là](https://embeddedcentric.com/lesson-2-ble-profiles-services-characteristics-device-roles-and-network-topology/)). Pour résumer ce que j'ai compris du BLE, il y a :
- Des Serveurs, qui ont 
    - Des Services, qui ont 
        - Des Caractéristiques, qui ont
            - Une valeur, qui peut changer
            - La capacité d'émettre un évènement pour prévenir que leur valeur a changé
- Des Clients, qui
    - Se connectent à des serveurs et
        - Parcourent leurs services et
            - Parcourent leurs Caractéristiques et
                - Lisent leur valeur
                - Peuvent s'abonner aux évènements, ou quelque chose dans le genre.

# Ce qui est utilisé

## Le serveur
Dans mon cas j'utilisais un [EmotiBit](https://www.emotibit.com/). L'idée était qu'il prenne des mesures pendant un certain temps, puis les transmette à une machine immobile à la fin de la journée.
L'Emotibit repose sur l'[Adafruit HUZZAH32](https://www.adafruit.com/product/3405), c'est une carte ESP32 qui sait faire du bluetooth et un tas d'autres choses. Il y a [cette librairie](https://github.com/espressif/arduino-esp32/tree/master/libraries/BLE) qui fonctionne bien sur cette carte pour faire du BLE.

## Le client
J'ai écrit le client en python, en utilisant la librairie [Bleak](https://github.com/hbldh/bleak). Initiallement je comptais utiliser [pybluez](https://github.com/pybluez/pybluez), mais la dernière release avait 3 ans, ça m'a effrayé.

## L'objectif

L'objectif c'est d'atteindre un système qui fonctionne comme ça : 
1. Si rien n'est connecté au serveur on ne fait rien de spécial côté BLE
2. Si quelque chose est connecté, la valeur de la caractéristique contient le nombre de fichiers disponibles
3. Une fois que le nombre de fichier a été lu par un client, et s'il y a un fichier à envoyer : 
    a. La valeur de la caractéristique prend la valeur des 256 prochains octets du fichier
        - s'il n'y a plus rien à lire dans le fichier, on le supprime et retour à l'étape **2**
    b. Une fois que la valeur a été lue, on retourne à l'étape **3.a**


# Le code

## Côté arduino/esp32

```
🚧 Je ne maitrise pas du tout le C++, ça se sent dans mon code mais il a le mérite de fonctionner.
```
### On met en place le BLE
Créer le service, les caractéristiques

```
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include <BLECharacteristic.h>
#include <BLE2902.h>

#define SERVICE_UUID        "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
#define CHARACTERISTIC_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"

BLECharacteristic* strCharacteristic = NULL;
void setup() 
{
...

//Setup BLE
  BLEDevice::init("Mon device BLE");
  BLEServer *pServer = BLEDevice::createServer();
  BLEService *pService = pServer->createService(SERVICE_UUID);
  strCharacteristic = pService->createCharacteristic(
    CHARACTERISTIC_UUID,
    BLECharacteristic::PROPERTY_READ   |
    BLECharacteristic::PROPERTY_INDICATE
  );
  strCharacteristic->addDescriptor(new BLE2902());
  pService->start();
  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(true);
  pAdvertising->setMinPreferred(0x06);  // functions that help with iPhone connections issue
  pAdvertising->setMinPreferred(0x12);
  BLEDevice::startAdvertising();
...

}
```

En fouillant un peu je me suis rendu compte qu'on peut mettre en place des callbacks, ça a l'air pratique ! Donc on les défini :

```
class MyBLEServerCallbacks: public BLEServerCallbacks {
  void onConnect(BLEServer* pServer){
    bleState = CONNECTED;  // ça je l'explique plus tard, c'est pour une state machine
    fileTransferState = NO_FILE; // ça je l'explique plus tard, c'est pour une state machine
    currentFile = SD.open("jexistepas");
  }

  void onDisconnect(BLEServer* pServer){
    onClientLost();
    BLEDevice::startAdvertising();
  }
};

class ContentCharacteristicCallbacks: public BLECharacteristicCallbacks  {
  void onStatus(BLECharacteristic* pCharacteristic, Status s, uint32_t code){
    if(s == Status::SUCCESS_INDICATE){
      if(fileTransferState == FILE_DONE)  // ça je l'explique plus tard, c'est pour une state machine
        fileTransferState = FILE_DONE_CONFIRMED;  // ça je l'explique plus tard, c'est pour une state machine
      else
        fileTransferState = FILE_PART_RECEIVED;  // ça je l'explique plus tard, c'est pour une state machine
      //TODO delete file if FILE_DONE_CONFIRMED
    }
    else
    if(s == Status::ERROR_NO_CLIENT){
      onClientLost();
    }
  }
};
```
Et ensuite on les ajoute à notre serveur et à la caractéristique dans la fonction `setup`.

```
  ...
  BLEDevice::init("Mon device BLE");
  BLEServer *pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyBLEServerCallbacks());
  BLEService *pService = pServer->createService(SERVICE_UUID);
  strCharacteristic = pService->createCharacteristic(
    CHARACTERISTIC_UUID,
    BLECharacteristic::PROPERTY_READ   |
    BLECharacteristic::PROPERTY_WRITE  |
    BLECharacteristic::PROPERTY_INDICATE
  );
  strCharacteristic->setCallbacks(new ContentCharacteristicCallbacks());
  ...
```


### Machine à état, et logique d'envoi de fichiers
Reste encore à mettre en place la logique pour envoyer le fichier.

```
🚧 Si on était sérieux on mettrai en place un peu de chiffrement lors du transfert des données, 
peut-être même des logiques de contrôle d'intégrité, mais là 
👏 j'ai 👏 pas 👏 envie 👏 de 👏 m'embêter 👏.
```

Déjà une machine à état (deux en fait) pour savoir où on en est. 
```
enum BleState {
  NOT_CONNECTED = 0,
  CONNECTED = 1
};

enum FileTransferState {
  NO_FILE = 9999,
  FILE_AVAILABLE = 10000,
  SENDING_FILE_PART = 10001,
  FILE_PART_RECEIVED = 10002,
  FILE_DONE = 10003,
  FILE_DONE_CONFIRMED = 10004,
  SENDING_AVAILABLE_FILE = 10005
};

BleState bleState = NOT_CONNECTED;  // L'état initial
FileTransferState fileTransferState = NO_FILE; // L'état initial


```

Ensuite, dans le `void loop` on peut se mettre en place un truc comme ça :
``` 
if(bleState == CONNECTED)
  {
    if(fileTransferState == NO_FILE || fileTransferState == FILE_AVAILABLE  || fileTransferState == FILE_DONE_CONFIRMED){
      String valueStr = String(fileTransferState)+"|"+String(bleFilesCount());
      strCharacteristic->setValue(valueStr.c_str());
      strCharacteristic->indicate();
    }
    else {
      if(fileTransferState == SENDING_FILE_PART || fileTransferState == FILE_DONE){
        // On appelle indicate pour prévenir le client qu'il a quelque chose à lire
        strCharacteristic->indicate();
      }
      if(fileTransferState == FILE_PART_RECEIVED){
        bleFileNext();
      }
    }

    delay(10);
  }
``` 

Il manque la partie où on modifie la caractéristique BLE pour envoyer le fichier _pour de vrai_ par paquets de 256 octets, en fait ça se passe dans la fonction `bleFileNext` :

```
bool bleFileNext(){
  if(!currentFile){
    currentFile = emotibit.getFirstFile();
  }
  if(!currentFile){
    fileTransferState = NO_FILE;
    return false;
  }
  byte buffer [256];
  int bytesRead = currentFile.read(buffer, 256);
  String data = String(bytesRead)+"|";
  
  if(0 == bytesRead){
    currentFile.close();
    //TODO delete the file if that was read
    currentFile = SD.open("jexistepas"); // un petit bricolage parce que je maitrise pas trop le C++
    fileTransferState = FILE_DONE;
    strCharacteristic->setValue(data.c_str());
    return false;
  }

  for(int i = 0 ; i < bytesRead ; i++){
    data += (char) buffer[i];
  }
  strCharacteristic->setValue(data.c_str());
  fileTransferState = SENDING_FILE_PART;
  return true;
}
```

Il manque aussi la fonction `bleFilesCount`, qui lit le nombre de fichiers à envoyer et transitionne la machine à état en conséquence : 
```
int bleFilesCount(){
  int count = combienYATIlDeFichiersDansMaCarteSD(); // en fait j'ai pas encore implémenté ça
  if(count > 0){
    fileTransferState = FILE_AVAILABLE;
  } else {
    fileTransferState = NO_FILE;
  }
  
  return count;
}
```

## Un client en python

En python c'était plus simple, 

On commence par reporter les différents 'statuts' qu'on a prévu dans les valeurs de la caractéristique bluetooth : 
```
class StartValues(str, Enum):
    NO_FILE = "9999"
    FILE_AVAILABLE = "10000"
    SENDING_FILE_PART = "10001"
    FILE_PART_RECEIVED = "10002"
    FILE_DONE = "10003"
    FILE_DONE_CONFIRMED = "10004"
    SENDING_AVAILABLE_FILE = "10005"
```

### Lister les appareils à proximité : 

```
>>> from bleak import BleakScanner
>>> import asyncio
>>> loop = asyncio.new_event_loop()
>>> loop.run_until_complete(BleakScanner.discover())
[BLEDevice(666AFE17-6931-F308-9D7F-452FC325A891, A5 Emotibit), BLEDevice(FB8EE2A1-2B7C-CD5E-11D5-26BBE9B7C141, iPhone de Elias)]
>>> 
```

### Se connecter 

Et un peu de logique pour se connecter et écouter les messages :
```python
class BluetoothDeviceObserver:

    def __init__(self, device_id):
        self.device_id = device_id
        self.lib_device = None
        self.client: BleakClient = None
        self.is_observing = False
        self.files = {}
        self.current_file = None

    @property
    def is_connected(self):
        if self.client is None:
            return False
        else:
            return self.client.is_connected

    async def connect(self):
        if self.client is None:
            self.lib_device = await BleakScanner.find_device_by_address(
                self.device_id
            )
            if self.lib_device is None:
                raise Exception("Could not find requested device")
            else:
                self.client = BleakClient(self.lib_device)
        if not self.is_connected:
            await self.client.connect()

    async def disconnect(self):
        await self.client.disconnect()

    def get_device(self) -> BluetoothDevice:
        return BluetoothDevice.from_ble_device(self.lib_device)

    async def start_observing(self):
        services = await self.client.get_services()
        char = services.get_characteristic(
            "beb5483e-36e1-4688-b7f5-ea07361b26a8"
        )
        self.is_observing = True
        await self.client.start_notify(
            char,
            self.on_char_notif
        )
```

Et une fonction qui lit les valeurs successives de la caractéristique bluetooth :

```python
    async def on_char_notif(self, char, v):
        str_value = v.decode("utf-8").split("|")
        start_value = str_value[0]
        actual_value = "|".join(str_value[1:])
        if start_value == StartValues.NO_FILE and actual_value == "false":
            await self.stop_observing()
        if start_value in [
            StartValues.SENDING_AVAILABLE_FILE,
            StartValues.FILE_DONE_CONFIRMED
        ] and actual_value != "false":
            if actual_value not in self.files:
                self.files[actual_value] = ""
            self.current_file = actual_value
        if start_value not in [e.value for e in StartValues]:
            if self.current_file in self.files:
                self.files[self.current_file] += actual_value
```

Jusqu'ici on garde les fichiers en mémoire vive. On peut les écrire sur le disque dans une autre fonction.

```python
    async def stop_observing(self):
        self.is_observing = False
        print("Stopped observing")
        await self.client.stop_notify("beb5483e-36e1-4688-b7f5-ea07361b26a8")
        await self.disconnect()
        if self.files:
            for k, v in self.files.items():
                with open(f".tmp/{k}", "w") as out_file:
                    print(f"{k} => {v}")
                    out_file.write(v)
        print("Done retrieving files")
```

Ensuite on peut l'utiliser comme ça : 
```
>>> from features.bluetooth.repository import BluetoothDeviceObserver
>>> observer = BluetoothDeviceObserver("666AFE17-6931-F308-9D7F-452FC325A891")
>>> loop.run_until_complete(observer.connect())
>>> loop.run_until_complete(observer.start_observing())
>>> observer.files
{'file_12202200123.csv': '1 [...] 11235,11229‘},
>>> loop.run_until_complete(observer.stop_observing())
```


# Petit bilan

C'est pas super optimisé, ça pourrait sûrement être plus rapide et safe, mais j'ai au moins un genre de POC. Je note ça ici parce que ça pourrait toujours servir plus tard.

Envoyer des fichiers depuis Arduino en bluetooth

## 

[https://ciechanow.ski/](https://ciechanow.ski/)

[https://www.joelonsoftware.com/](https://www.joelonsoftware.com/)

[https://garden.bradwoods.io/](https://garden.bradwoods.io/) 

[https://bradfrost.com/blog/](https://bradfrost.com/blog/) 

[https://www.garbageday.email/](https://www.garbageday.email/)

[http://cromagnontech.blogspot.com/](http://cromagnontech.blogspot.com/)

[https://bryce.co/](https://bryce.co/)

[https://taylor.town/](https://taylor.town/)


🏠	Paris
Par mail	contact@eliassebbar.info

A propos

Notes

Projets

Contact

Elias Sebbar

Ingénieur logiciel freelance à Paris

\

🧑‍🎨

_

|

📷