Bluetooth GATT data getting corrupted in flight

Question

I'm using noble to consume my bleno peripheral. The data buffer I return in my onReadRequest() callback is somehow getting corrupted when it gets to my noble Characteristic.read(). I dump the buffer right before the callback in my onReadRequest() and I dump it right away when I get it in Characteristic.read():

Consumer

...
Characteristic.read((err, data) => {
      if (err) {
        reject(err);
      } else {     
        console.log(data);
      }
    });
...

Producer

...
const bleno = require('bleno');

const flags = {
    a: 1 << 0,
    b: 1 << 1,
    c: 1 << 2
  },
  numBytesInReturnData = 18,
  supportedFlags = flags.a | flags.b | flags.c,
  accelPrecision = Math.pow(10, 5),
  bPrecision = Math.pow(10, 3);

module.exports = class DataCharacteristic extends bleno.Characteristic {
  constructor(pin) {
    super({
      uuid: '1234',
      properties: ['read'],
      descriptors: [new bleno.Descriptor({
        uuid: '2901',
        value: 'blah'
      })]
    });
    this._hardware = hardware;
    this._hasData = false;
    this._dataBuffer = new Buffer.allocUnsafe(numBytesInReturnData).fill(0);
  }

  onReadRequest(offset, callback) {
    if (!offset) {
      this._hasData = false;
      this._dataBuffer.fill(0);
      Promise.all([
          this._hardware.getA),
          this._hardware.getB(),
          this._hardware.getC(),
        ]).then((responses) => {
          this._dataBuffer.writeUInt8(supportedFlags, 0);

          this._dataBuffer.writeUInt8(responses[0], 1);
          this._dataBuffer.writeInt32LE(responses[0] * aPrecision, 2, true);
          this._dataBuffer.writeInt32LE(responses[2].x * accelPrecision, 6, true); //accel
          this._dataBuffer.writeInt32LE(responses[2].y * accelPrecision, 10, true);
          this._dataBuffer.writeInt32LE(responses[2].z * accelPrecision, 14, true);

          console.log(this._dataBuffer);

          this._hasData = true;
          callback(this.RESULT_SUCCESS, this._dataBuffer);
        })
        .catch(err => {
          console.error('Error when reading hardware data', err);
          callback(this.RESULT_UNLIKELY_ERROR);
        });
    } else if (this._hasData) { //reading a second time for rest of data
      callback(this.RESULT_SUCCESS, this._dataBuffer.slice(offset));
    } else {
      callback(this.RESULT_ATTR_NOT_LONG);
    }
  }
}

Producer outupt

<Buffer 07 00 00 00 00 00 c2 c9 ff ff e4 2c 00 00 1c 47 0f 00>

consumer outupt

<Buffer 07 00 00 00 00 00 c2 c9 ff ff 5f 34 00 00 5f 43 0f 00>

As you can see only part of the buffer gets corrupted. Why does this happen?

Answer 1

Might you be reading immediately after the peripheral notifies or indicates? If so, it may be that the data being passed to your read callback is actually data from the last notify or indicate. See this issue here.