Nous allons voir ici les deux fonctions les plus importantes dans un code Arduino standard.

La fonction setup()

Appelée une fois par le code, elle servira à initialiser vos variables, paramètres et objets.

Dans notre cas, elle est un peu longue, surtout à cause de la définition des comportements du module Bluetooth.

La voici intégralement :

void setup()
{
  Serial.begin(115200);

  // set parameters for the PulseSensor
  pulseSensor.analogInput(PULSE_INPUT);
  pulseSensor.setSerial(Serial);
  pulseSensor.setThreshold(THRESHOLD);
  pulseSensor.begin() ;

  // activate BLE Module
  ble.begin() ;

  // reset all parameters
  ble.factoryReset() ;

  // don't repeat any sent command in the terminal
  ble.echo(false) ;

  // check if version is enough to support consistant connexion
  if ( !ble.isVersionAtLeast(MINIMUM_FIRMWARE_VERSION) )
  {
    error( F("Callback requires at least 0.7.0") ) ;
  }

  // Give a name to your device that will be seen on the network
  ble.sendCommandCheckOK(F("AT+GAPDEVNAME=BlePulseSensor")) ;

  // Clean any previous Service/Characteristic
  if (! ble.sendCommandCheckOK( F("AT+GATTCLEAR")))
  {
    error(F("Could not clear services and characteristics")) ;
  }

  // add a custom service
  Serial.println(F("Adding the Heart Service definition (UUID = 0x180D): ")) ;
  customServiceId = gatt.addService(0x180D) ;
  if (customServiceId == 0)
    error(F("Could not add Heart service")) ;

  // add a heartrate characteristic with notification of an array of 1 value
  Serial.println(F("Adding the custom notifiable characteristic definition (UUID = 0x2a37): ")) ;
  customNotificationCharId = gatt.addCharacteristic(0x2a37, GATT_CHARS_PROPERTIES_NOTIFY, 1, 1, BLE_DATATYPE_BYTEARRAY, "Heart Rate") ;
  if (customNotificationCharId == 0)
    error(F("Could not add heartrate notification characteristic")) ;

  // add the heart service to the advertising data (needed for Nordic apps to detect the service)
  Serial.print(F("Adding Custom Service UUID to the advertising payload: "));
  uint8_t advdata[] { 0x02, 0x01, 0x06, 0x03, 0x02, 0x0d, 0x18} ;
  ble.setAdvData( advdata, sizeof(advdata) ) ;

  // reset your BLE module
  ble.reset() ;
}

Pour comprendre à quoi correspond chaque ligne, je vous invite à lire dans un premier temps les commentaires dans le code (les textes qui se trouvent soit entre deux “balises” * et *, soit sur une ligne démarrant par //.

Les commentaires sont des morceaux de texte dans un code qui 1/ ne seront pas compilés, 2/ sous certaines conditions peuvent être utilisés pour automatiser la production d’une documentation.

Nous allons toutefois entrer dans les détails de quelques lignes.

ble.sendCommandCheckOK(F("AT+GAPDEVNAME=BlePulseSensor")) ;

Cette ligne permet de définir le nom sous lequel notre périphérique apparaîtra lorsqu’il sera scanné sur les réseaux. On peut le laisser libre ou au contraire suivre un certain nombre de règles qui permettront par exemple de mieux l’identifier sur nos applications futures en filtrant les dipositifs scannés par leur nom.

customNotificationCharId = gatt.addCharacteristic(0x2a37, GATT_CHARS_PROPERTIES_NOTIFY, 1, 1, BLE_DATATYPE_BYTEARRAY, "Heart Rate") ;

C’est peut-être la commande la plus importante. Elle définit les format et modalités de notification de notre caractéristique.

Le premier paramètre (0x2a37) correspond à ce que l’on appelle l’UUID de notre caractéristique. Elle est importante ici, car elle répond aux spécifications GATT (voir partie 01 du tuto à ce sujet), et sera ainsi reconnue comme une caractéristique notifiant la fréquence cardiaque.

Le second paramètre est celui qui indique que notre caractéristique utilise les notifications. Elle pourrait être en effet de différents types :

• GATT_CHARS_PROPERTIES_BROADCAST
• GATT_CHARS_PROPERTIES_READ
• GATT_CHARS_PROPERTIES_WRITE_WO_RESP
• GATT_CHARS_PROPERTIES_WRITE
• GATT_CHARS_PROPERTIES_NOTIFY
• GATT_CHARS_PROPERTIES_INDICATE

Les chiffres 1 et à nouveau 1 indiquent ici le nombre minimal et le nombre maximal de valeurs qui seront envoyées à chaque fois.

Enfin, BLE_DATATYPE_BYTEARRAY signifie que nous enverrons nos données sous la forme d’un tableau de bytes, mais nous pourrions avoir choisi les autres types suivants :

• BLE_DATATYPE_AUTO
• BLE_DATATYPE_STRING
• BLE_DATATYPE_BYTEARRAY
• BLE_DATATYPE_INTEGER

Le type auto n’est pas un type en soit, mais on signifie par là que le type de variable envoyée déterminera le type. Mouais ^^ pas hyper conseillé.

Egalement, le type INTEGER a tout l’air d’une bonne idée au début, plus facilement manipulable que les tableaux de bytes. C’est sans compter les habitudes prises de l’autre côté par les librairies. La plupart attendront soit des bytes soit des strings, et il sera très difficile de les nourrir avec autre chose.

On vous conseille donc de rester le plus possible avec des tableaux de bytes, de choisir le type string lorsque c’est vraiment nécessaire, et d’oublier les autres.

Le dernier paramètres de la fonction est une chaîne de caractère qui sera affiché dans la description de notre caractéristique. Elle sera très utile pour des personnes qui souhaitent comme vous connaître un peu plus ce qu’il se passe sous le capot.

Et rien ne vous empêche d’y laisser de petits messages persos 😉

Et voilà, nos modules bluetooth et PulseSensor ont été initialisés, et chacun vit désormais sa propre vie. Le capteur capte et le bluetooth streame.

Maintenant, il nous faut récupérer les informations du capteurs et les transmettre au module bluetooth pour qu’il les communique. C’est notre dernière étape, la fonction loop, qui comme son nom l’indique bien sera appelée en boucle par le microcontroleur Feather.

C’est notre dernière étape, elle est plus simple et plus rapide.

La fonction loop()

void loop()
{
  if (pulseSensor.sawNewSample())
  {
      // look if a pulse has been detected
      if (pulseSensor.sawStartOfBeat())
      {
        // get value and send through gatt object
        uint8_t dataForNotification = pulseSensor.getBeatsPerMinute() ;  
        gatt.setChar(customNotificationCharId, &dataForNotification, 1) ;
      }
  } 
}

Cette fonction permet de vérifier à l’acquisition de chaque nouveau sample par le capteur si un “Beat” a été détecté, soit une durée entre deux pics.

Si c’st le cas, alors nous récupérons la valeur calculée par la librairie, qui est ici la fréquence instantanée. La fréquence instantanée se définit par l’inverse (multiplié par 60 pour convertir en BPM) de l’intervalle entre deux pics, appelé IBI. On a donc FC = 60/IBI.

Une fois que cette fréquence est calculée, nous la passons à l’objet GATT qui la notifiera à tous les périphériques à l’écoute.

Voici le code dans son intégralité :

#define USE_ARDUINO_INTERRUPTS false
#include <Arduino.h>
#include <PulseSensorPlayground.h>
#include “BluefruitConfig.h”
#include “Adafruit_BLE.h”
#include “Adafruit_BluefruitLE_SPI.h”
#include “Adafruit_BluefruitLE_UART.h”
#include “Adafruit_BLEGatt.h”

const int PULSE_INPUT = A0 ;
const int THRESHOLD = 550 ;

int32_t customServiceId ;
int32_t customNotificationCharId ;

PulseSensorPlayground pulseSensor ;

#define MINIMUM_FIRMWARE_VERSION “0.7.0”
Adafruit_BluefruitLE_SPI ble(BLUEFRUIT_SPI_CS, BLUEFRUIT_SPI_IRQ, BLUEFRUIT_SPI_RST) ;
Adafruit_BLEGatt gatt(ble) ;

void error(const __FlashStringHelper * err)
{
    Serial.println(err) ;
    while(1) ;
}

void setup()
{
  Serial.begin(115200);

  // set parameters for the PulseSensor
  pulseSensor.analogInput(PULSE_INPUT);
  pulseSensor.setSerial(Serial);
  pulseSensor.setThreshold(THRESHOLD);
  pulseSensor.begin() ;
 
 // activate BLE Module
  ble.begin() ;

  // reset all parameters
  ble.factoryReset() ;

  // don't repeat any sent command in the terminal
  ble.echo(false) ;

  // check if version is enough to support consistant connexion
  if ( !ble.isVersionAtLeast(MINIMUM_FIRMWARE_VERSION) )
  {
    error( F("Callback requires at least 0.7.0") ) ;
  }

  // Give a name to your device that will be seen on the network
  ble.sendCommandCheckOK(F("AT+GAPDEVNAME=BlePulseSensor")) ;

  // Clean any previous Service/Characteristic
  if (! ble.sendCommandCheckOK( F("AT+GATTCLEAR")))
  {
    error(F("Could not clear services and characteristics")) ;
  }

  // add a custom service
  Serial.println(F("Adding the Heart Service definition (UUID = 0x180D): ")) ;
  customServiceId = gatt.addService(0x180D) ;
  if (customServiceId == 0)
    error(F("Could not add Heart service")) ;

  // add a heartrate characteristic with notification of an array of 1 value
  Serial.println(F("Adding the custom notifiable characteristic definition (UUID = 0x2a37): ")) ;
  customNotificationCharId = gatt.addCharacteristic(0x2a37, GATT_CHARS_PROPERTIES_NOTIFY, 1, 1, BLE_DATATYPE_BYTEARRAY, "Heart Rate") ;
  if (customNotificationCharId == 0)
    error(F("Could not add heartrate notification characteristic")) ;

  // add the heart service to the advertising data (needed for Nordic apps to detect the service)
  Serial.print(F("Adding Custom Service UUID to the advertising payload: "));
  uint8_t advdata[] { 0x02, 0x01, 0x06, 0x03, 0x02, 0x0d, 0x18} ;
  ble.setAdvData( advdata, sizeof(advdata) ) ;

  // reset your BLE module
  ble.reset() ;
}

void loop()
{
  if (pulseSensor.sawNewSample())
  {
      // look if a pulse has been detected
      if (pulseSensor.sawStartOfBeat())
      {
        // get value and send through gatt object
        uint8_t dataForNotification = pulseSensor.getBeatsPerMinute() ;  
        gatt.setChar(customNotificationCharId, &dataForNotification, 1) ;
      }
  } 
}

Il est temps maintenant de brancher nos câbles et de vérifier la bonne exécution du code.