CoreBlueTooth: Getting error even if data is written into writable characteristics

Question

I am using CoreBlueTooth framework to write into one of the writable characteristics of Peripheral. I am implementing "didWriteValueForCharacteristic:error:" delegate in central which is always returning me below error. Though I have received data on my peripheral.

Error Domain=CBErrorDomain Code=0 "Unknown error." UserInfo=0x166762e0 {NSLocalizedDescription=Unknown error.}

In my code my self.data is a NSDictionary with 3 keys and values.

// Central

- (void)centralManagerDidUpdateState:(CBCentralManager *)iCentral {
    if (iCentral.state != CBCentralManagerStatePoweredOn) {
        return;
    }

    [self.centralManager scanForPeripheralsWithServices:self.peripheralServices options:@{ CBCentralManagerScanOptionAllowDuplicatesKey : @YES}];
}


- (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)iPeripheral advertisementData:(NSDictionary *)iAdvertisementData RSSI:(NSNumber *)iRSSI {
    if (self.discoveredPeripheral != iPeripheral) {
        // Save a local copy of the peripheral, so CoreBluetooth doesn't get rid of it
        self.discoveredPeripheral = iPeripheral;

        // Connect to the discovered peripheral
        [self.centralManager connectPeripheral:iPeripheral options:nil];
    }
}

- (void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)iPeripheral advertisementData:(NSDictionary *)iAdvertisementData RSSI:(NSNumber *)iRSSI {
    if (self.discoveredPeripheral != iPeripheral) {
        // Save a local copy of the peripheral, so CoreBluetooth doesn't get rid of it
        self.discoveredPeripheral = iPeripheral;

        // Connect to the discovered peripheral
        [self.centralManager connectPeripheral:iPeripheral options:nil];
    }
}


// We've connected to the peripheral, now we need to discover the services and characteristics to find the 'writeable' characteristic.
- (void)centralManager:(CBCentralManager *)iCentral didConnectPeripheral:(CBPeripheral *)iPeripheral {
    // Stop scanning
    [self.centralManager stopScan];

    // Make sure we get the discovery callbacks
    iPeripheral.delegate = self;

    // Search only for services that match our UUID
    [iPeripheral discoverServices:self.peripheralServices];
}


- (void)peripheral:(CBPeripheral *)iPeripheral didDiscoverServices:(NSError *)iError {
    if (iError) {
        [self cleanup];
        return;
    }

    // Loop through the newly filled peripheral.services array, just in case there's more than one.
    for (CBService *service in iPeripheral.services) {
        [iPeripheral discoverCharacteristics:@[self.writeableCharactersticsUUID] forService:service];
    }
}


// Write the data into peripheral's characterstics
- (void)peripheral:(CBPeripheral *)iPeripheral didDiscoverCharacteristicsForService:(CBService *)iService error:(NSError *)iError {
    if (iError) {
        [self cleanup];

        return;
    }

    // Find out the writable characterstics
    for (CBCharacteristic *characteristic in iService.characteristics) {
        if ([characteristic.UUID isEqual:self.writeableCharactersticsUUID]) {
            NSData *dataToWrite = [NSJSONSerialization dataWithJSONObject:self.data options:0 error:nil];
            NSInteger dataSize = [[NSByteCountFormatter stringFromByteCount:dataToWrite.length countStyle:NSByteCountFormatterCountStyleFile] integerValue];
            if (dataSize > 130) {
                NSLog(@"Cannot send more than 130 bytes");
                return;
            }

            [self.discoveredPeripheral writeValue:dataToWrite forCharacteristic:self.centralWriteableCharacteristic type:CBCharacteristicWriteWithResponse];

            break;
        }
    }
}


- (void)peripheral:(CBPeripheral *)iPeripheral didWriteValueForCharacteristic:(CBCharacteristic *)iCharacteristic error:(NSError *)iError {
    NSLog(@"Error = %@", iError);
}


- (void)cleanup {
    // Don't do anything if we're not connected
    if (self.discoveredPeripheral.state != CBPeripheralStateConnected) {
        return;
    }

    // If we've got this far, we're connected, but we're not subscribed, so we just disconnect
    [self.centralManager cancelPeripheralConnection:self.discoveredPeripheral];
}


// Peripheral

- (void)peripheralManagerDidUpdateState:(CBPeripheralManager *)iPeripheral {
    if (iPeripheral.state != CBPeripheralManagerStatePoweredOn) {
        return;
    }

    CBMutableCharacteristic *characteristic = [[CBMutableCharacteristic alloc] initWithType:iCID properties:CBCharacteristicPropertyWrite value:nil permissions:CBAttributePermissionsWriteable];

    CBMutableService *writableService = [[CBMutableService alloc] initWithType:iServiceId primary:YES];
    writableService.characteristics = @[characteristic];

    //[self.peripheralManager removeAllServices];
    [self.peripheralManager addService:writableService];
    [self.peripheralManager startAdvertising:@{ CBAdvertisementDataServiceUUIDsKey : @[iServiceId]}];
}

- (void)peripheralManager:(CBPeripheralManager *)iPeripheral didReceiveWriteRequests:(NSArray *)iRequests {
    CBATTRequest *aRequest = iRequests[0];
    NSData *aData = aRequest.value;
    NSDictionary *aResponse = (NSDictionary *)[NSJSONSerialization JSONObjectWithData:aData options:NSJSONReadingMutableContainers error:nil];

    NSLog(@"Received Data = %@", aResponse);
}

Answer 1

I have figured it out. The issue was with Characteristics type. Instead of "CBCharacteristicWriteWithResponse" I used "CBCharacteristicWriteWithoutResponse" and it worked.

I did this after reading this:

writeValue forCharacteristic writeType, this function is the primary function for writing to a characteristic on a device. the writeType property is either set to write with no response or write with response. When write with response is used, all writes to the peripheral are cached while the iOS device is waiting to receive the ok response and the callback. When write no response is used, the data will not be cached. This is important when using things which need low latency, like an RC car or helicopter etc. when using write with response, the iOS device may sometime lag behind, which does not make great response … For each write the didWriteCharacteristic callback is called.