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];
}