## 

[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/)

[https://greg.technology/](https://greg.technology/)


Sites que j'aime

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

A force d'en voir dans des installations d'art numérique, j'ai fini par avoir envie d'avoir ma propre imprimante thermique, histoire de voir ce qu'on peut faire avec.

Je tombe sur une Epson TM-T20II à 35 euros sur Leboncoin. Après une ou deux recherches sur internet j'apprends que : 
- Le protocole ESC/POS a l'air d'être le standard pour contrôler les imprimantes thermiques
- Il y a une [librairie python](https://github.com/python-escpos/python-escpos) qui a l'air bien maintenue qui sait faire de l'ESC/POS par usb
- L'Epson TM-T20II gère ce protocole et a une prise USB

Ça me suffit, je la prends.

# Parler à l'imprimante

J'ai reçu l'imprimante, maintenant comment est-ce que je fait pour lui parler ? 
python-escpos est plutôt bien documenté, je suis [les instructions d'installation](https://python-escpos.readthedocs.io/en/latest/user/installation.html) : je commence par ignorer les instructions à propos des règles udev -> ça ne fonctionne pas -> je décide de ne pas ignorer les instructions à propos des règles udev :

- Je repère le vendorId et le productId de mon imprimante avec `lsub`: 
```
 $ lsusb
(...)
Bus 001 Device 008: ID 04b8:0e15 Seiko Epson Corp. TM-T20II
(...)
```

- Dans `/etc/udev/rules.d/50-myusb.rules`, j'écris : 
```
SUBSYSTEM=="usb", ATTRS{idVendor}=="04b8", ATTRS{idProduct}=="0e15" GROUP="users", MODE="0666", SYMLINK+="usbtm20"
```

Ensuite, un coup de `sudo service udev restart`

Et je me retrouve avec un script python qui parvient à imprimer du texte sur l'imprimante : 
```
from escpos.printer import Usb

text = "..."

device = Usb(0x04B8, 0xE15, 0, profile="TM-T20II")
device.textln(text)
device.cut()
```



![IMG_4171.JPG](https://demisel.space/garage/uploads/IMG_4171_4730b6665b.JPG)

Ok ça a l'air de fonctionner, mais pourquoi ça n'imprime pas sur toute la largeur de mon rouleau de 80mm ? On dirait que la machine crois que je lui ai chargé un rouleau de 58mm ? 

# Modifier la largeur de la zone d'impression

Epson publie une [documentation plutôt détaillée](https://download4.epson.biz/sec_pubs/pos/reference_en/escpos/index.html) (mais pas forcément évidente à naviguer) sur le protocole ESC/POS et le support de ses commandes par son matériel.
Je finis par tomber sur [`GS ( E <fn=5>`](https://download4.epson.biz/sec_pubs/pos/reference_en/escpos/gs_lparen_ce_fn05.html) : 
![GS-E-fn5.png](https://demisel.space/garage/uploads/GS_E_fn5_87a89c0867.png)
A priori, avec `a=3`, je peux configurer la largeur du papier : 
![params_gs-e-a_3.png](https://demisel.space/garage/uploads/params_gs_e_a_3_22e2442898.png)

La documentation précise que cette fonction n'a un effet que si l'appareil est en mode "user settings" :
![gs-e-note-settings-mode.png](https://demisel.space/garage/uploads/gs_e_note_settings_mode_b89f5c4247.png)

Dans le cas de la fonction [`GS ( E <fn=1>`](https://download4.epson.biz/sec_pubs/pos/reference_en/escpos/gs_lparen_ce_fn01.html), l'imprimante n'entre pas directement dans le mode user setting. Il faut attendre qu'elle transmette la valeur `0x372000` avant de lui envoyer de nouvelles commandes.
![gs-e-change-notice.png](https://demisel.space/garage/uploads/gs_e_change_notice_3f4227468c.png)
En fouillant un peu, on trouve la fonction [`GS ( E <fn=2>`](https://download4.epson.biz/sec_pubs/pos/reference_en/escpos/gs_lparen_ce_fn02.html) qui permet de sortir du mode "user setting". 
Je termine avec ce bout de code qui permet de changer la taille du papier configurée dans l'imprimante : 
```
from escpos.printer import Usb
from time import sleep

def enter_settings_mode(d):
    # Enter user setting mode
    # GS ( E <Function 1>
    enter = bytes.fromhex("1D2845030001494E")
    d._raw(enter)
    # Await confirmation from printer
    # that we entered user setting mode
    for i in range(100):
        res = d._read()
        if(len(res) == 0):
            sleep(.1)
            continue
        elif(res[0] == 55 and res[1] == 32):
            break

def exit_settings_mode(d):
    # Exit user setting mode
    # GS ( E <Function 2>
    exit = bytes.fromhex("1D28450400024F5554")
    d._raw(exit)

def change_paper_size():
    d = Usb(0x04b8,0x0e15, 0, profile="TM-T20II")


    enter_settings_mode(d)
    
    # Switch to 80mm paper width
    # Set config value
    # GS ( E <Function 5>
    # Set paper width
    paper_width = bytes.fromhex("1D2845040005030600")
    d._raw(paper_width)

    exit_settings_mode()
```
Les impressions occupent maintenant toute la largeur du papier. 
![IMG_4172.JPG](https://demisel.space/garage/uploads/IMG_4172_cae745d946.JPG)


# Imprimer des images

Il y a déjà les fonctions nécessaires pour imprimer des images dans python-escpos : 
```
from PIL import Image
from escpos.printer import Usb

im = Image.open("(...)")
d = Usb(0x04b8,0x0e15, 0, profile="TM-T20II")
d.image(
        im,
        center=True
    )
d.cut()
```

Je suis content, ça imprime mon image, mais il y a des traits qui gachent un peu tout :
![IMG_4173.JPG](https://demisel.space/garage/uploads/IMG_4173_3973936494.JPG)

En fouillant dans la doc epson, je finis par tomber sur [une page qui parle de l'impression d'images](https://download4.epson.biz/sec_pubs/pos/reference_en/epos_print/ref_epos_print_xml_en_xmlforcontrollingprinter_image.html#i875697) à partir de... je sais pas trop, des fichiers xml qu'on mettrait dans un logiciel particulier ? Bref, sur cette page on lit : 

```
If you set to print a raster image in grayscale, the amount of data of the image increases and may be printed intermittently, which causes white streaks on printout. 
```

Donc... s'il y a trop de données à imprimer, l'imprimante pourrait décider de faire de petites pauses, qui entrainent l'apparition de traits blancs. Ça a tout l'air de correspondre au problème qu'on rencontre !
Dans la documentation de la commande [`ESC *`](https://download4.epson.biz/sec_pubs/pos/reference_en/escpos/esc_asterisk.html), on remarque qu'un paramètre permet de sélectionner les densités d'impression horizontales et verticales. En mettant le nez dans le code de python-escpos, on remarque les paramètres `high_density_vertical` et `high_density_horizontal`, qui agissent justement sur ces paramètres d'`ESC *`. 
Après de petites modifications sur le code d'esc_pos pour redimensionner l'image pour l'impression en faible densité, on imprime une image sans lignes qui gâchent tout !
![IMG_4174.JPG](https://demisel.space/garage/uploads/IMG_4174_6ad15a90dd.JPG)
C'est mieux ! Mais on perd quand même énormément en qualité d'impression... Et en plus il y a encore des lignes parasites.

Mais en fait, la documentation dit que "the amount of data of the image increases and may be printed intermittently". Ça veut dire que l'imprimante a besoin de respirer lorsqu'on lui envoie beaucoup de données ? Peut-être que ça se passerait mieux si on imprimait plus doucement ? 

On retourne à la commande [`GS ( E <fn=5>`](https://download4.epson.biz/sec_pubs/pos/reference_en/escpos/gs_lparen_ce_fn05.html), puisqu'elle permet aussi de définir une vitesse d'impression ! On fait ça avec ce bout de code : 
```
def change_print_speed():
    d = get_device()

    enter_settings_mode(d)

    speed = bytes.fromhex("1D2845040005060100")
    d._raw(speed)

    exit_settings_mode(d)
```

Ça imprime bien moins rapidement, mais l'image rend beaucoup mieux.

![IMG_4176.JPG](https://demisel.space/garage/uploads/IMG_4176_409e262228.JPG)
