Problème connexion Nrf5283 et ESP32

Bonjour à tous.
voici un nouveau cas.
j ai un module qui recueille la cadence par ble.
j ai réglé mon NRF52 en mode central pour récupérer les infos de la cadence et les logger
jusque la pas trop de problème. (quoi que)
je voudrai maintenant afficher la vitesse et la cadence sur un M5stickC a base d ESP32.
dois regler l esp32 en mode périphérique et le connecter à la nrf52 ou dois je utiliser la Nrf52 en mode dual (central/peripherique)

cadence -->Nrf52-->EPS32 ou cadence -->Nrf52<--EPS32

dois je utiliser le profil UART pour faire transiter les infos ?

voici le code du nrf52. pour le esp32 j ai rien fait pour l instant
merci

#include <bluefruit.h>
int lastCrankEventTime;
int crankRevolutions;
int cumulcrankRevolutions;
float timeDifference;
float crankEven;
float presentCrankEven;
float deltaCrank;
float NumDeltaCrank;
float deltaTime;
int cadence;

BLEClientService        cscs(UUID16_SVC_CYCLING_SPEED_AND_CADENCE);
BLEClientCharacteristic cscc(UUID16_CHR_CSC_MEASUREMENT);


void setup()
{
  Serial.begin(115200);
  while ( !Serial ) delay(10);   // for nrf52840 with native usb

  Serial.println("Bluefruit52 Central Custom CSC Example");
  Serial.println("--------------------------------------\n");

  // Initialize Bluefruit with maximum connections as Peripheral = 0, Central = 1
  // SRAM usage required by SoftDevice will increase dramatically with number of connections
  Bluefruit.begin(0, 1);
  Bluefruit.setTxPower(4);
  Bluefruit.setName("Bluefruit52 Central");

  // Initialize CSC client
  cscs.begin();

  // Initialize client characteristics of CSC.
  // Note: Client Char will be added to the last service that is begin()ed.
  // bslc.begin();

  // set up callback for receiving measurement
  cscc.setNotifyCallback(csc_notify_callback);
  cscc.begin();

  // Increase Blink rate to different from PrPh advertising mode
  Bluefruit.setConnLedInterval(250);

  // Callbacks for Central
  Bluefruit.Central.setDisconnectCallback(disconnect_callback);
  Bluefruit.Central.setConnectCallback(connect_callback);

  /* Start Central Scanning
   * - Enable auto scan if disconnected
   * - Interval = 100 ms, window = 80 ms
   * - Don't use active scan
   * - Filter only accept csc service
   * - Start(timeout) with timeout = 0 will scan forever (until connected)
   */
  Bluefruit.Scanner.setRxCallback(scan_callback);
  Bluefruit.Scanner.restartOnDisconnect(true);
  Bluefruit.Advertising.setInterval(32, 244);    // in unit of 0.625 ms
  //Bluefruit.Advertising.setFastTimeout(30); 
  //Bluefruit.Scanner.filterUuid(cscs.uuid);
  Bluefruit.Scanner.useActiveScan(false);
  Bluefruit.Scanner.start(0);                   // // 0 = Don't stop scanning after n seconds
}

void loop()
{
  // do nothing
}

/**
 * Callback invoked when scanner pick up an advertising data
 * @param report Structural advertising data
 */
void scan_callback(ble_gap_evt_adv_report_t* report)
{
  // Since we configure the scanner with filterUuid()
  // Scan callback only invoked for device with csc service advertised
  // Connect to device with csc service in advertising
  Bluefruit.Central.connect(report);
}

/**
 * Callback invoked when an connection is established
 * @param conn_handle
 */
void connect_callback(uint16_t conn_handle)
{
  Serial.println("Connected");
  Serial.print("Discovering CSC Service ... ");

  // If csc is not found, disconnect and return
  if ( !cscs.discover(conn_handle) )
  {
    Serial.println("Found NONE");

    // disconnect since we couldn't find csc service
    Bluefruit.disconnect(conn_handle);

    return;
  }

  // Once csc service is found, we continue to discover its characteristic
  Serial.println("Found it");
  
  Serial.print("Discovering Measurement characteristic ... ");
  if ( !cscc.discover() )
  {
    // Measurement chr is mandatory, if it is not found (valid), then disconnect
    Serial.println("not found !!!");  
    Serial.println("Measurement characteristic is mandatory but not found");
    Bluefruit.disconnect(conn_handle);
    return;
  }
  Serial.println("Found it");

  

  // Reaching here means we are ready to go, let's enable notification on measurement chr
  if ( cscc.enableNotify() )
  {
    Serial.println("Ready to receive CSC Measurement value");
  }else
  {
    Serial.println("Couldn't enable notify for CSC Measurement. Increase DEBUG LEVEL for troubleshooting");
  }
}

/**
 * Callback invoked when a connection is dropped
 * @param conn_handle
 * @param reason is a BLE_HCI_STATUS_CODE which can be found in ble_hci.h
 */
void disconnect_callback(uint16_t conn_handle, uint8_t reason)
{
  (void) conn_handle;
  (void) reason;

  Serial.print("Disconnected, reason = 0x"); Serial.println(reason, HEX);
}


/**
 * Hooked callback that triggered when a measurement value is sent from peripheral
 * @param chr   Pointer client characteristic that even occurred,
 *              in this example it should be cscc
 * @param data  Pointer to received data
 * @param len   Length of received data
 */
void csc_notify_callback(BLEClientCharacteristic* chr, uint8_t* data, uint16_t len)
{
  crankEven=data[4]*256+data[3];
  presentCrankEven=cumulcrankRevolutions*256+crankRevolutions;
  deltaCrank=crankEven-presentCrankEven;
  NumDeltaCrank=deltaCrank/1024;
  deltaTime=data[1]-lastCrankEventTime;
  cadence=deltaTime*60/NumDeltaCrank;
   Serial.print("cadence = ");
   Serial.println(cadence); 
   lastCrankEventTime =  data[1];
   crankRevolutions = data[3];
   cumulcrankRevolutions = data[4];
}

Bonsoir

Pourquoi ne pas essayer transposer le code du Nrf5283 vers l'ESP32, ce dernier traiterait avec la caractéristique du capteur et en en plus assurerait l'affichage, de loin ça parait plus simple que l'association capteur -> nrf5283 -> ESP32

Sinon il me semble que l'ESP peut être configuré en périphérique
Le nrf5283 y écrirait dans un caractéristique contenant la donnée à afficher
l'exemple BLE_uart pour ESP32 peut peut être servir de base un 'afficheur BLE'