---
# System prepended metadata

title: Tennis FIPA

---

# EPS32_Tennis_Score_Board_with_BLE :tennis: :pager: 

## Présentation du projet

---

### Description 

Ce projet vise à créer un compteur de points sans fil pour les parties de tennis. Le système se compose d'une station affichant les points, qui constitue le cœur du système, et de deux télécommandes sans fil à un seul bouton, permettant d'incrémenter les scores des joueurs à distance.

#### Pour la station : 
* La partie calcul est assurée par un ESP32C3_LUATOS_CORE, qui est équipé d"un ESP32-C3, avec Wifi, BLE 5, I/O etc. 

| ESP32C3_LUATOS_CORE |
|:---:|
| <img src="https://hackmd.io/_uploads/S1WqGq66T.jpg" alt="Carte-de-d-veloppement-ESP32-TYPE-C" width="" height="300"> |

La communication sans fil est gérée par le protocole BLE 5 (Bluetooth Low Energy) :signal_strength: de l'ESP32-C3, et sera connectée à des télécommandes BLE pour recevoir les informations de points des joueurs.

Un affichage composé de 8 afficheurs 7 segments de 10x7cm et 2 points avec des LEDs adressables de type WS2812B permet de présenter les points aux joueurs. :pager:
Chaque afficheur est constitué de 2 LEDs par segment, soit 14 LEDs par afficheur, pour un total de 114 LEDs (7 * 2 * 8 et 2 * 1).

| WS2812B_LED | NEO_7_SEGMENT | 
|:---:| :-----------: | 
| <img src="https://hackmd.io/_uploads/BJSh6N8I6.jpg" alt="WS2812B_LED" width="" height="200"> | <img src="https://hackmd.io/_uploads/SJwF7cp66.jpg" alt="Circuit imprimé 7 segment." width="" height="400"> |
| https://amzn.eu/d/7VvVpYE | |
| Q = 114 | Q = 8 |
| 4€/100u | 1€/u (JLCPCB) |




* La station est alimentée par 4 batteries :battery:  de type **18650** avec un shield V9, rechargeable à partir d'un port USB-C.
Cela devrait permetre une autonomie d'environ 1h30.



| Shield 18650 | 
| :-----------: | 
| <img src="https://hackmd.io/_uploads/rkgMrNLLa.jpg" alt="Bouclier-de-batterie-au-lithium-pour-18650" width="" height="300"> |
| https://amzn.eu/d/aoC9qMg |
| Q = 1 |
| 15€/u|




* La station est equipée d'un buzzer pour signaler l'actualisation des points :first_place_medal: 

| Buzzer | 
| :-----------: | 
| <img src="https://hackmd.io/_uploads/BJslKy106.jpg" alt="Buzzer" width="" height="150"> |
| https://amzn.eu/d/bEpB45T |
| Q = 1 |
| 1.6€/u|


---

#### Pour les télécommandes :

L'achat d'un bouton de prise de photo à distance, détourné de son usage initial, présente l'avantage du prix et de la simplicité d'utilisation "plug and play".


| selfie_buttoon_BLE | 
| :--------: |
|   <img src="https://hackmd.io/_uploads/r1oHU9666.jpg" alt="selfie_button_BLE" width="" height="300">|
| https://amzn.eu/d/5w4gfyo |
|Q = 2 |
| 5€/u |

---

#### consommables :

| lots JST SM 3 Pin Connecteur | 6PCS USB-C USB Type C Câble d'extension | 
| :--------: | :--------: |
|   <img src="images\JST SM 3.jpg" alt="selfie_button_BLE" width="" height="300">|<img src="images\USB-C USB Type C.jpg" alt="selfie_button_BLE" width="" height="300">|
| https://amzn.eu/d/cDDCiCn |https://amzn.eu/d/72TUqbl |
|Q = 1 |Q = 1 |
| 10€/u |8€/u |

## Simulation

La simulation est effectuée sur la plateforme en ligne Wokwi, qui offre un émulateur de matériel pour le développement sur microcontrôleurs, y compris l'ESP32. Conçu pour simplifier le processus de prototypage et de test, Wokwi permet aux développeurs de simuler et de déboguer leur code sans avoir besoin de matériel physique.

https://wokwi.com/projects/386908507872286721

![simulation](https://hackmd.io/_uploads/SyqaU1J0p.jpg)


---
## Code

Le code est écrit en langage C et est destiné à être exécuté sur un microcontrôleur ESP32. Il utilise plusieurs bibliothèques pour la gestion des LED (Adafruit_NeoPixel), les boutons (Bounce2), et la communication Bluetooth Low Energy (BLE) (NimBLEDevice).

Les principales parties du code sont les suivantes :

### Librairies utilisées :

- `#include <Adafruit_NeoPixel.h>` : Pour la gestion des LEDs NeoPixel.
- `#include <Bounce2.h>` : Pour la gestion des rebonds des boutons.
- `#include <NimBLEDevice.h>` : Pour la gestion de la communication Bluetooth Low Energy (BLE).

### Définition des constantes et des broches :

Le code définit différentes constantes et broches utilisées pour les LEDs, les boutons, et le buzzer. Par exemple, `PIXEL_PER_SEGMENT` représente le nombre de LEDs par segment, `PIXELS_DIGITS` le nombre de chiffres par joueur, etc.

### Initialisation des objets et des variables :

- `NUM_LEDS` : Calcul du nombre total de LEDs sur les deux bandes (strips).
- `Bounce2::Button` : Définition des objets de la classe Bounce2 pour chaque bouton.
- `Adafruit_NeoPixel strip_P1`, `Adafruit_NeoPixel strip_P2` : Initialisation des objets pour les LEDs NeoPixel des deux joueurs.
- `GameState` et `PlayerScore` : Définition d'énumérations pour les états du jeu et les scores des joueurs.
- `PlayerData players_dat[]` : Définition d'une structure pour stocker les données de chaque joueur (LED strip, score, jeu, set, adresse BLE, notification).
- `byte segments[7]` et `byte digits[11]` : Définition d'arrays pour les segments et les chiffres à afficher.

### Configuration Bluetooth :

Définition de constantes pour les services, caractéristiques, etc., nécessaires à la communication BLE. Configuration des callbacks et des fonctions nécessaires à la gestion de la connexion BLE.

---
#### Par exemple :

Pour ce projet, nous considérerons les deux télécommandes des joueurs comme des serveurs auxquels l'ESP32 va s'abonner. Nous choisirons un service et une caractéristique permettant de recevoir une notification d'un des serveurs, et d'ajouter un point au joueur correspondant.

Dans ce cas, nous ciblerons le service HID (Human Interface Device) et la caractéristique de rapport de données. Pour cela, nous avons besoin des UUID BLE (Universally Unique Identifier for Bluetooth Low Energy) définis par la norme BLE.

Les UUID BLE conformes à la norme Bluetooth SIG sont généralement représentés sous forme de chaînes hexadécimales à 128 bits, utilisées dans le code.

```cpp
const char HID_SERVICE[] = "1812";        //Définit le service cible HID(Human Interface Device) de la norme Bluetooth
const char HID_INFORMATION[] = "2A4A";    //Définit la caractéristique cible d'information du service HID
const char HID_REPORT_MAP[] = "2A4B";     //Définit la caractéristique cible de report du service HID
const char HID_CONTROL_POINT[] = "2A4C";  //Définit la caractéristique cible de control du service HID
const char HID_REPORT_DATA[] = "2A4D";    //Définit la caractéristique cible des donnée du service HID
```

Voici les UUID BLE conformes à la norme Bluetooth SIG pour les services et caractéristiques mentionnés :

- `HID_SERVICE` : "0000**1812**-0000-1000-8000-00805f9b34fb"
- `HID_INFORMATION` : "0000**2a4a**-0000-1000-8000-00805f9b34fb"
- `HID_REPORT_MAP` : "0000**2a4b**-0000-1000-8000-00805f9b34fb"
- `HID_CONTROL_POINT` : "0000**2a4c**-0000-1000-8000-00805f9b34fb"
- `HID_REPORT_DATA` : "0000**2a4d**-0000-1000-8000-00805f9b34fb"


1. **HID_SERVICE** : "Human Interface Device Service"
   - Ce service représente un périphérique d'interface utilisateur, généralement un clavier, une souris ou un autre dispositif d'entrée similaire.

2. **HID_INFORMATION** : "HID Information"
   - Cette caractéristique fournit des informations sur le périphérique HID, telles que le numéro de version, le fabricant, etc.

3. **HID_REPORT_MAP** : "Report Map"
   - Cette caractéristique décrit le format des données rapportées par le périphérique HID. Elle spécifie la structure des rapports de données que le périphérique envoie.

4. **HID_CONTROL_POINT** : "HID Control Point"
   - Cette caractéristique permet à un client d'envoyer des commandes au périphérique HID. Par exemple, cela pourrait être utilisé pour activer ou désactiver certaines fonctionnalités.

5. **HID_REPORT_DATA** : "Report Data"
   - Cette caractéristique est utilisée pour transmettre les données de rapport du périphérique HID. Les données rapportées peuvent inclure des informations provenant d'un clavier, d'une souris ou d'autres types de dispositifs d'entrée.

En résumé, ces services et caractéristiques définissent une infrastructure standardisée pour les périphériques HID Bluetooth, ce qui permet une communication cohérente entre ces périphériques et d'autres dispositifs compatibles avec la norme Bluetooth.

![BLE_char](https://hackmd.io/_uploads/H1xObUyAa.jpg)




### Fonctions pour la gestion de l'affichage des LEDs :

- `clearDisplay` : Fonctions pour remettre a 'Zero' l'affichage des scores d'un joueurs.
- `clearBoard` : Fonctions pour remettre a 'Zero' la totalité de l'affichage des scores.
- `displayAdvantage` : Fonction pour afficher l'avantage d'un joueur.
- `writeDigit` : Fonction pour afficher un chiffre sur les LEDs.

### Fonctions pour la gestion du jeu :

- `verif_score` : Fonction pour vérifier le score et déterminer l'état du jeu. (Permet de mettre a jour la machine d'état.)
- `updatePlayers` : Fonction pour mettre à jour l'affichage des scores, jeux, et sets des joueurs.
- `removePlayer` : Fonction pour supprimer un joueur de la liste. (Déconnection BLE par exemple.)

### Boucle principale (`loop`) :

La boucle principale gère les entrées des boutons, la communication BLE, et l'état du jeu en fonction des actions des joueurs.

Le code utilise des états (`GameState`) pour suivre le déroulement du jeu, des fonctions pour gérer l'affichage des LEDs et la communication BLE, ainsi que des interruptions pour détecter les pressions des boutons.

### Machine d'état simplifié :
```mermaid
---
title: STATE ENGINE
---
stateDiagram-v2
    state if_state_P1 <<choice>>
    state if_state_P2 <<choice>>

    state if_state_P1_1 <<choice>>
    state if_state_P2_1 <<choice>>

    state fork_state <<fork>>

    
    [*] --> WAITING_TO_START 
    WAITING_TO_START  --> IN_PROGRESS : Joueur 1 et Joueur 2 présents.
    IN_PROGRESS --> fork_state
    IN_PROGRESS --> IN_PROGRESS : Point marqué
    fork_state --> JOUEUR_1 : Joueur 1 40 points et marque le point
    fork_state --> JOUEUR_2 : Joueur 2 40 points et marque le point
    fork_state --> EQUALITY : Joueur 1 & Joueur 2 40 points

   
    state JOUEUR_1{
        [*] --> J1_GAME
        GOTO_IN_PROGRESS_P1: GOTO_IN_PROGRESS
        J1_GAME --> if_state_P1_1 : Si Joueur 1 Score 
        if_state_P1_1 --> J1_SET : True
        if_state_P1_1 --> GOTO_IN_PROGRESS_P1 : False
        J1_SET --> if_state_P1  : SI Joueur 1 SET ==2
        if_state_P1 --> J1_WIN : True
        if_state_P1 --> GOTO_IN_PROGRESS_P1 : False
    }
    
    state JOUEUR_2{

        [*] --> J2_GAME
        GOTO_IN_PROGRESS_P2: GOTO_IN_PROGRESS
        J2_GAME --> if_state_P2_1 : Si Joueur 2 Score 
        if_state_P2_1 --> J2_SET : True
        if_state_P2_1 --> GOTO_IN_PROGRESS_P2 : False
        J2_SET --> if_state_P2  : SI Joueur 2 SET ==2
        if_state_P2 --> J2_WIN : True
        if_state_P2 --> GOTO_IN_PROGRESS_P2 : False
        
    }
    
    state EQUALITY{
        state if_state_P1_EQ <<choice>>
        state if_state_P2_EQ <<choice>>
        [*] --> EQUALITY_STATE
        EQUALITY_STATE --> J1_ADVANTAGE
        EQUALITY_STATE --> J2_ADVANTAGE
        J1_ADVANTAGE --> if_state_P1_EQ : SI point pour J1 
        J2_ADVANTAGE --> if_state_P2_EQ : SI point pour J2 
        if_state_P1_EQ --> EQUALITY_STATE : FALSE
        if_state_P2_EQ --> EQUALITY_STATE : FALSE
        if_state_P1_EQ --> GOTO_JOUEUR_1 : TRUE
        if_state_P2_EQ --> GOTO_JOUEUR_2 : TRUE
    }
```

---
## Cirtuit et routage

#### Circuit 7 Segments

![7_SEG_Schema](https://hackmd.io/_uploads/rJ9sbueCp.png)

Les fichiers Gerber pour la reproduction de 7 Segments sont disponible [ICI](CAO\Gerber_ESP_7_Segment.zip)




#### Circuit Station


![Shéma_station](https://hackmd.io/_uploads/r15hKtgA6.png)

| circuit_top | circuit_bottom | 
| :--------: | :--------: |
|   <img src="images\circuit_top.jpeg" alt="circuit_top" width="300" height="">|<img src="images\circuit_bottom.jpeg" alt="circuit_bottom" width="300" height="">|

---
## Mise en caisse

Nous avons fabriqué une boîte en bois OSB de 15 mm pour créer l'afficheur de score, ce qui permet de protéger la partie électronique et les batteries, tout en facilitant le déplacement de l'afficheur.

![croquis_frame](images/croquis_frame.JPG)
![Frame_real](images/frame.jpeg)

Pour les boutons, nous avons conçu deux types de panneaux : un pour les joueurs et un pour l'alimentation et le Bluetooth.

| player_panel | Power_panel | 
| :--------: | :--------: |
|   <img src="images\player_panel.jpeg" alt="player_panel" width="300" height="">|<img src="images\Power_panel.jpeg" alt="Power_panel" width="300" height="">|

---
## Pièces 3D

Les pièces peuvent être retrouvées dans le dossier [Pièces 3D](Pieces_3D/) du Git.
Vous y trouverez les fichiers STL pour les afficheurs 7 Segments, ainsi que les panneaux des joueurs et d'alimentation.

---
## Essais

* Lors de nos tests, nous avons obtenu un maximum de 3 heures et 30 minutes d'affichage avec une charge complète.

* Nous avons remarqué que le buzzer émettant les signaux sonores n'est pas assez puissant.

---

## Utilisation

* L'utilisation se veut simple : on allume l'afficheur en appuyant une fois sur le bouton d'alimentation. Les 7 segments s'allument et affichent "- - --". L'afficheur attend alors deux joueurs.

* Pour allumer la télécommande du joueur 1, celle-ci clignote. En maintenant le bouton d'appairage Bluetooth enfoncé pendant environ 3 secondes, puis en le relâchant, la télécommande devrait maintenant être appariée. Un signal sonore de confirmation retentit et les 7 segments attribués au joueur de la télécommande passent de "- - --" à "0 0 00".

* Répétez la même manipulation pour le joueur 2.

* Une fois les deux télécommandes appairées, vous pouvez maintenant jouer. À chaque pression sur une télécommande, le score du joueur concerné devrait s'incrémenter.

* Une fois la partie terminée ou lorsque vous êtes épuisé, il suffit d'appuyer deux fois sur le bouton d'alimentation pour éteindre l'afficheur.


## Améliorations possibles

* Il pourrait être utile de remplacer le buzzer par une référence plus puissante.

* Un circuit imprimé sur mesure serait un ajout intéressant, notamment pour pallier au manque d'informations sur l'état de la batterie, que ce soit en cours d'utilisation ou de charge. Pour cela, il est possible de dupliquer le circuit du shield 18650 V9 et de l'intégrer au projet. Cela permettrait un design plus robuste ainsi qu'un affichage de l'état de la batterie sur l'afficheur.

* Une personnalisation des couleurs des LEDs pourrait être une option sympathique via l'ajout d'un bouton supplémentaire.