Send Data from CentralManager to PeripheralManager using CoreBluetooth (BLE) - ios

I have my app running on two iOS device (both have 6.1.4) where one device acts as the Central and one acts as a Peripheral.
I have been successful in getting notifications (characteristics set up to notify) from the Peripheral over to the Central just fine.
However, I was wanting to write a value from the Central to the Peripheral to a specific writable characteristic but that always fails.
The peripheral:didWriteValueForCharacteristic:error: delegate's method is immediately called where the error description says:
"One or more parameters were invalid"
I have been searching the net for any clues but have yet to come up with what is wrong.
This is how I setup the characteristic on the peripheral side:
[[CBMutableCharacteristic alloc] initWithType:<My CBUUID> properties:CBCharacteristicPropertyWrite value:nil permissions:0];
I see that when I discover characteristics on the Central side that my writeable characteristic is there. I do store away a reference at that point that I later try to use when writing my value. The value that I am writing is just a text string that I convert to a NSData like so:
NSString *payloadMessage = #"Hello";
NSData *payload = [payloadMessage dataUsingEncoding:NSUTF8StringEncoding];
[peripheral writeValue:payload forCharacteristic:<myCharacteristic> type:CBCharacteristicWriteWithResponse];
The only odd thing I can see is that my characteristic's properties is set to 138. It looks like it is both writeable as well as having extended properties. Not sure why that is automatically added by the CoreBluetooth framework. Don't know if it matters.
It seems like something is wrong with the characteristic or the data that I am trying to send but for the life of me I can not figure it out. If anyone out there has any suggestions or ideas I would appreciate the help

I did receive an answer in the Bluetooh-dev list that solved my problem.
I didn't create my characteristic with the right permissions.
This is what I originally had:
[[CBMutableCharacteristic alloc] initWithType:<CBUUID> properties:CBCharacteristicPropertyWrite value:nil permissions:0];
This is what it should be:
[[CBMutableCharacteristic alloc] initWithType:<CBUUID> properties:CBCharacteristicPropertyWrite value:nil permissions: **CBAttributePermissionsWriteable**];

I got the same error when I accidentally provided an array of strings instead of CBUUIDs in discoverCharacteristics:forService:.
Incorrect:
[peripheral discoverCharacteristics:#[NOTIFY_CHARACTERISTIC_UUID, WRITE_WO_RESPONSE_CHARACTERISTIC_UUID]
forService:service];
Correct:
[peripheral discoverCharacteristics:#[[CBUUID UUIDWithString:NOTIFY_CHARACTERISTIC_UUID],
[CBUUID UUIDWithString:WRITE_WO_RESPONSE_CHARACTERISTIC_UUID]]
forService:service];

Create characteristic
self.writeableCharacteristic = [[CBMutableCharacteristic alloc] initWithType:[CBUUID UUIDWithString:CBUUIDWriteableCharacteristicCodeString] properties:CBCharacteristicPropertyWrite value:nil permissions:CBAttributePermissionsWriteable];
Add it to service and to PeripheralManager
CBMutableService *gameTransferService = [[CBMutableService alloc] initWithType:[CBUUID UUIDWithString:CBUUIDServiceCodeString] primary:YES];
gameTransferService.characteristics = #[self.notifierCharacteristic, self.writeableCharacteristic];
[self.peripheralRoleManager addService:gameTransferService];
Make sure u are connected to another device
[self.service connectToPerephiral:self.dataSource[indexPath.row]];
Found u characteristic in connected peripheral and write data
for(CBService *service in self.discoveredPeripheral.services) {
if([service.UUID isEqual:[CBUUID UUIDWithString:<CBUUIDServiceCodeString>]]) {
for(CBCharacteristic *charac in service.characteristics) {
if([charac.UUID isEqual:[CBUUID UUIDWithString:<CBUUIDWriteableCharacteristicCodeString>]]) {
[self.discoveredPeripheral writeValue:data forCharacteristic:charac type:CBCharacteristicWriteWithResponse];
}
}
}
}
Add delegate method - (void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveWriteRequests:(NSArray<CBATTRequest *> *)requests and found u'r characteristic like
for (CBATTRequest *request in requests) {
if ([request.characteristic.UUID isEqual:[CBUUID UUIDWithString:CBUUIDNotifierCharacteristicCodeString]]) {
#ifdef DEBUG
NSString *dataString = [[NSString alloc] initWithData:request.value encoding:NSUTF8StringEncoding];
NSLog(#"Received from manager - %#", dataString);
#endif
if (self.delegate && [self.delegate respondsToSelector:#selector(BLEServiceDidReceiveData:peripheral:service:)]) {
[self.delegate BLEServiceDidReceiveData:request.value peripheral:nil service:self];
}
}
}

Related

Central to communicate with multiple peripherals at once

I'm trying to get my central (iOS device) to communicate with two peripherals (one iOS device, one not). Individually they work fine but I'm finding that once I get both peripherals involved, only the peripheral that was connected to the most recently is able to receive data from the central device. Is there a way to send data from the central to each peripheral without disconnecting and reconnecting the peripheral?
This is my code for writing to peripheral:
- (void) peripheral: (CBPeripheral *)peripheral didUpdateValueForCharacteristic:(CBChatacteristic *)characteristic error:(NSError *)error{
NSString *newValue = [[NSString alloc] initWithData:characteristic.value encoding:NSUTF8StringEncoding];
NSLog(#"Received: %# from %#", newValue, peripheral.name);
CBPeripheral *sender = peripheral;
if([newValue isEqualToString:#"ready"]){
NSData *messageValue = [#"challenge dataUsingNSUTF8StringEncoding];
[sender writeValue:messageValue forCharacteristic:_writeCharacteristic type:CBCharacteristicWriteWithResponse];
NSLog(#"Challenge sent to %#", sender.name);
}
Breakpoints indicate the code is being executed and the log shows "challenge sent" to the correct peripheral, it's just that peripheral never receives it.
Code for peripheral receiving:
-(void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveWriteRequests:(NSArray<CBATTRequest *> *) requests{
for(int i=0; i<requests.count; i++){
CBATTRequest *request = requests[i];
if([request.characteristic.UUID isEqual:_writeCharacteristic.UUID]){
NSString *stringValue = [[NSString alloc] initWithData:request.value encoding:NSASCIIStringEncoding];
NSLog(#"Write Request: %#", stringValue);
}
}
To answer your question: Yes it is possible that you can have multiple connections to different peripherals and read/write to them. iOS devices can handle up to 8 simultaneous connections.
For the implementation, have a look at the Core Bluetooth Programming Guide from Apple. All the things you need are explained there.
Just as a suggestion: If multiple devices (let's call them B and C) should receive data from 1 device (called A), I would use the peripheral role on device A that needs to send the data to the others. Because then devices B and C can scan, connect and subscribe to a characteristic and receive updates without having to read again.

Write to multiple bluetooth Peripherals from Central

I've searched SO for help on this and haven't found anything that will answer, address or get me pointed in the right direction so I've decided to post my issue.
I have a BT Central app running on an Apple TV. I have a peripheral app running on an iPhone and iPad.
The central app is able to connect to both peripheral devices just fine. I'm able to transfer all kinds of data to the central app and have control over all of the phases of the session (didDiscoverPeripheral, didDiscoverServices, didDiscoverChracteristics, etc.) All the delegate methods on both central and peripheral sides are behaving exactly as they should.
When the central app connects to a peripheral and it discovers the "writable" characteristic it sends (writes) an NSString to the peripheral with something like "Hi iPad, you've connected to central" or "Hi iPhone you've connected to central". In doing this I know that everyone is connected, discovered, processed and a reference to the peripherals is saved. None of this is an issue and behaves exactly as is documented by Apple.
On the central app I have a UIButton that performs a write to all of the connected peripherals. I attempt to loop through the connected peripherals and write something to each one inside the loop. Unfortunately only the last connected peripheral receives the written data.
I have a nice NSDictionary of all of the peripheral information and object that I enumerate through. I've even based the loop on the
retrieveConnectedPeripheralsWithServices method. My peripherals all use a custom class for their delegate so I know I'm not crossing the same delegate with multiple peripherals.
Inside the loop I can see that the peripheral is connected, the characteristic I'm targeting has writeWithResponse properties and write permissions. No reference to the peripheral has been lost or released. Everything maps out and looks great.
I just can't write to all the connected peripherals from inside a loop. I've tried queuing up the writes in an NSOperation and or dispatch_async in case it's a timing thing but nothing is working.
If the iPad is the last connect peripheral it gets the write. If the iPhone connect last then it gets the write. The last connected peripheral is the only clue I've got to go on but I'm just not seeing the problem.
At this point I'm out of sticks and carrots and several days of googling and SO searching. Sorry for the long post but I wanted to explain and also show that I'm not just asking out of laziness but have sincerely tried everything I know.
Thanks for any help.
Added relevant code:
-(void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary *) advertisementData RSSI:(NSNumber *)RSSI {
//it's in range - have we already seen it?
if([self findPeripheralMatching:peripheral.identifier] == nil) {
//hack if the advertisingData local name or the peripheral GATT name is NULL
NSDictionary *dict = [self cleanupAdvertisementData:peripheral advertisementData:advertisementData];
if(dict == nil) {
[self stop];
[self start];
return;
}
//save a local copy of the peripheral, so CoreBluetooth doesn't get rid of it
XCBluetoothPeripheralDictionary *obj = [[XCBluetoothPeripheralDictionary alloc] init];
obj.peripheral = peripheral;
obj.advertisementData = dict;
[self.peripheralDictionary setObject:obj forKey:[peripheral.identifier UUIDString]];
//and connect is not connected...
if(peripheral.state == CBPeripheralStateDisconnected) {
[self.centralManager connectPeripheral:peripheral options:nil];
}
} //findPeripheralMatching
} //didDiscoverPeripheral
-(void)centralManager:(CBCentralManager *)central didConnectPeripheral:(CBPeripheral *)peripheral {
//make sure we get the discovery callbacks
XCBluetoothPeripheral *pd = [[XCBluetoothPeripheral alloc] initWithDelegate:self];
pd.subscriptionDictionary = self.subscriptionDictionary;
peripheral.delegate = pd;
//save a copy of the XCPeripheral object
[self.peripheralDictionary objectForKey:[peripheral.identifier UUIDString]].delegate = pd;
//discover and search only for services that match our service UUID
[peripheral discoverServices:#[[CBUUID UUIDWithString:self.serviceUUID]]];
//notify the delegate we connected
XC_SelectorAssert(#selector(bluetoothCentralDidConnect:), self.delegate)
if (self.delegate && [self.delegate respondsToSelector:#selector(bluetoothCentralDidConnect:)]) {
XCBluetoothPeripheralDictionary *dict = [self.peripheralDictionary objectForKey:[peripheral.identifier UUIDString]];
[self.delegate bluetoothCentralDidConnect:dict];
} else {
NSAssert(NO, XCMissingSelectorForProtocol);
}
} //didConnectPeripheral
-(void)peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(NSError *)error {
if(error) {
[self callbackError:error];
return;
}
//again, we loop through the array, and if the characteristic matches
//whats in the subscriptionDictionary then we subscribe to it
for (CBCharacteristic *characteristic in service.characteristics) {
if([self isDesiredCharachteristic:characteristic.UUID]) {
[peripheral discoverDescriptorsForCharacteristic:characteristic];
if(characteristic.properties & CBCharacteristicPropertyNotify) {
[peripheral setNotifyValue:YES forCharacteristic:characteristic];
}
if(characteristic.properties & CBCharacteristicPropertyRead) {
}
if(characteristic.properties & CBCharacteristicPropertyWrite) {
NSLog(#"Writing value to %# - %#", peripheral.identifier, peripheral.name);
NSString *string = [NSString stringWithFormat:#"%# connected to %#",
peripheral.name,
[XCUtilities deviceName]];
[peripheral writeValue:[string dataUsingEncoding:NSUTF8StringEncoding]
forCharacteristic:characteristic
type:CBCharacteristicWriteWithResponse];
}
if(characteristic.properties & CBCharacteristicPropertyWriteWithoutResponse) {
}
[self.subscriptionDictionary objectForKey:(NSString *)characteristic.UUID].characteristic = characteristic;
} //if isMatching
} //for CBCharacteristic
} //didDiscoverCharacteristicsForService
The following method is called from an IBAction
-(void)writeValueToCharacteristic:(CBUUID *)cbuuid value:(NSString *)string {
//get a reference to the characteristic we specified
CBCharacteristic *chr = [self findCharacteristicMatching:cbuuid];
XC_CBCharacteristicAssert(chr)
//enumerate through the discovered peripherals
[self.peripheralDictionary enumerateKeysAndObjectsUsingBlock:^(NSString *key, XCBluetoothPeripheralDictionary *obj, BOOL *stop){
XC_CBPeripheralAssert(obj.peripheral)
if(obj.peripheral.state == CBPeripheralStateConnected) {
//check the properties
if(chr.properties & CBCharacteristicPropertyWriteWithoutResponse ||
chr.properties & CBCharacteristicPropertyWrite) {
NSLog(#"Writing value to:\n%#\n%#\n%#\n%#\n%#",
key,
obj.advertisementData,
obj.peripheral.name,
obj.peripheral.delegate,
obj.peripheral);
NSData *data = [string dataUsingEncoding:NSUTF8StringEncoding];
[obj.peripheral writeValue:data forCharacteristic:chr
type:CBCharacteristicWriteWithResponse];
} else {
[self localError:XC_BTErrorPermissionWritable description:XCErrorWritingCharacteristic];
}
} //is connected
}];
} //writeValueToCharacteristic
I would think that if something were wrong with the way I'm saving the peripherals or my custom dictionary or the way I'm using this stuff then my writes would fail for all peripherals and not just one of the two I'm testing with from inside a loop. And I know I'm connected and discovered and all is well because when central initially processes these peripherals it writes to each one as sort of a confirmation that they are indeed ready to go.
- (void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveWriteRequests:(NSArray *)requests {
[peripheral respondToRequest:[requests objectAtIndex:0] withResult:CBATTErrorSuccess];
CBATTRequest *aRequest = requests[0];
NSData *aData = aRequest.value;
NSString *string = [[NSString alloc] initWithData:aData encoding:NSUTF8StringEncoding];
[self logToDelegate:string];
}
-(void)peripheral:(CBPeripheral *)peripheral didWriteValueForCharacteristic:(CBCharacteristic *)characteristic
error:(NSError *)error {
if(error) {
[self callbackError:error];
return;
}
[self logToDelegate:#"didWriteValueForCharacteristic"];
} //didWriteValueForCharacteristic

iOS central writing is not permitted

I am a ios developer.
I can take a value from arduino sensor. But i cannot send a message by using the following the method.
[peripheral writeValue:dataToWrite forCharacteristic:characteristic type:CBCharacteristicWriteWithResponse];
"dataToWrite" value is alloc by using NSString*
NSString* data = #"1";
NSData* dataToWrite = [data dataUsingEncoding:NSUTF8StringEncoding];
and the following code is full code of "DiscoverCharacteristics in service"
//DISCOVER CHAR
-(void)peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:(CBService *)service error:(NSError *)error
{
if (error) {NSLog(#"DISCOVER_CHAR - Error");return;}
NSString* data = #"1";
NSData* dataToWrite = [data dataUsingEncoding:NSUTF8StringEncoding];
for (CBCharacteristic * characteristic in service.characteristics) {
NSLog(#"DISCOVER_CHAR - Characteristic : %#",characteristic);
[peripheral writeValue:dataToWrite forCharacteristic:characteristic type:CBCharacteristicWriteWithResponse];
}
}
In this point, I want to summarize my question.
My Question is
"Even i used the [Peripheral writeValue:forCharacteristic:type] Method. why an error message is shown in log monitor? " Like "Writing is not permitted."
Do i need to get some permission to writing the message for an Arduino?
OR I have to change my following code?
OR I have a problem in Arduino(Acutally, Arduino can get a message from other device... so, Arduino source code is fine. maybe...)
NSString* data = #"1";
NSData* dataToWrite = [data dataUsingEncoding:NSUTF8StringEncoding];
I'm a bit of a bluetooth noob. So it's probably something obvious I've overlooked but any help would be much appreciated.
Thank you!:)
Thank you a lot!!!!!!! Paulw11. Finally, i sent a data from iphone to Arduino. what i checked properties of my characteristic is
<CBCharacteristic: 0x13564a680, UUID = FFE1, properties = 0x16, value = (null), notifying = NO>.
My characteristic's properties = 0x16. but i can not find a 0x16 in enum of properties. Still, I don't know the 0x16 meaning. Someone said that "Values representing the possible properties of a characteristic. Since characteristic properties can be combined, a characteristic may have multiple property values set."
URL: Interpret Characteristic Properties (iOS and BLE) .
Anyway I could find a solution by PaulW11 help! How i can do it? Here is my way of solution.
At first, My method is [peripheral writeValue:dataToWrite forCharacteristic:characteristic *type:CBCharacteristicWriteWithResponse]*;.
The problem code is type field. I had to understand the type. The type has a meaning of write, read and so on. So, I changed the type from CBCharacteristicWriteWithResponse to CBCharacteristicPropertyWrite. That is what i did.
[peripheral writeValue:dataToWrite forCharacteristic:characteristic *type:CBCharacteristicPropertyWrite*];
Thank you again! Paulw11
try to print error inside following method:
-(void)peripheral:(CBPeripheral *)peripheral
didWriteValueForCharacteristic:(CBCharacteristic *)characteristic
error:(NSError *)error
{
NSLog(#"%#",error.localizedDescription);
}
If the error is "Writing is not permitted", then you might not writing the data correctly.Convert the string value in this format
NSData* data = [#"string_to_write" dataUsingEncoding:NSASCIIStringEncoding];
And try this:
[self.peripheral writeValue:data forCharacteristic:self.characteristic type:CBCharacteristicWriteWithoutResponse];
Hope it works!!

CoreBluetooth writing value to cached peripheral

So I'm working with two apps. One acts as the central, the other is the peripheral. There could be more than one devices that act as the peripheral. When the Central launches, it begins scanning for peripherals that are running a service I call UUIDService. This service has two characteristics: vendorUUID (read) and totalAmount (write).
When the Peripheral launches, it begins advertising UUIDService with it's -[UIDevice identifierForVendor] string as the value for vedorUUID and nil for totalAmount.
On Central, I have a singleton called BluetoothManager which holds a mutable array called connectedUsers to keep track of peripherals that are connected to the central. This is an array of BTUser objects which has two properties: uuid (NSString) and periph (CBPeripheral).
When Central discovers a peripheral, it creates the user object and fills in the reference to periph:
-(void)centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary *)advertisementData RSSI:(NSNumber *)RSSI
{
NSLog(#"Discovered periph advertising UUID Service");
BTUser* user = [[BTUser alloc] init];
user.periph = peripheral;
[_centralManager connectPeripheral:user.periph options:nil];
[_connectedUsers addObject:user];
NSLog(#"User periph: %#", user.periph.identifier);
}
This block of code works. _connectedUsers now contains one BTUser with a periph. Then it connects:
-(void)centralManager:(CBCentralManager *)central didConnectPeripheral:(CBPeripheral *)peripheral
{
NSLog(#"Connected periph: %#", peripheral.name);
BTUser* thisUser;
for (BTUser* user in _connectedUsers)
{
if ([user.periph.identifier isEqual: peripheral.identifier])
{
thisUser = user;
break;
}
}
thisUser.periph.delegate = self;
[thisUser.periph discoverServices:#[_uuidServiceUUID]];
}
I've confirmed this works, and the peripheral goes on to discover the service and and related characteristics. The issue I'm running into is when I go to use the reference to the peripheral to write to totalAmount.
-(void)initializePaymentWithUser:(BTUser*)user forAmount:(CGFloat)amount
{
_isListeningForUsers = NO;
[self stopScanningForUsers];
NSLog(#"disconnecting from all other users");
for (BTUser* u in _connectedUsers)
{
if (![u isEqual:user])
{
[u disconnectFromCentral:_centralManager];
}
}
CBService* uuidService = user.periph.services[0];
for (CBCharacteristic* cha in uuidService.characteristics)
{
if ([cha.UUID isEqual:_uuidServiceTotalAmountUUID])
{
NSLog(#"Writing total amount %.2f", amount);
NSData* data = [[NSString stringWithFormat:#"%.2f", amount] dataUsingEncoding:NSUTF8StringEncoding];
[user.periph writeValue:data
forCharacteristic:cha
type:CBCharacteristicWriteWithResponse];
break;
}
}
}
It makes it to the block that writes the value, and user.periph still has the same -[CBPeripheral identifier] as it did when it originally connected. But I'm getting the error:
CoreBluetooth[WARNING] <CBPeripheral: 0x14ed28c0 identifier = B4CB35CC-2C78-7543-B083-E0B373EF66D0, Name = "iPhone", state = connected> is not a valid peripheral
And the peripheral never calls -peripheral:didWriteValueForCharacteristic:error.
For completion to this questions, this is the block of code from the Peripheral responsible for advertising the UUIDService:
-(void)advertiseVendorUUID:(NSString*)uuid
paymentInitiatedBlock:(DOBluetoothPeripheralBlock)completion
{
_uuidService = [[CBMutableService alloc] initWithType: _uuidServiceUUID
primary:YES];
NSLog(#"Adding vendor id to characteristic: %#", uuid);
NSData* vendorData = [uuid dataUsingEncoding:NSUTF8StringEncoding];
_uuidServiceVendorUUIDChar = [[CBMutableCharacteristic alloc] initWithType:_uuidServiceVendorUUIDUUID
properties:CBCharacteristicPropertyRead
value:vendorData
permissions:CBAttributePermissionsReadable];
_uuidServiceTotalAmountChar = [[CBMutableCharacteristic alloc] initWithType:_uuidServiceTotalAmountUUID
properties:CBCharacteristicPropertyWrite
value:nil
permissions:CBAttributePermissionsWriteable];
_uuidService.characteristics = #[_uuidServiceVendorUUIDChar, _uuidServiceTotalAmountChar];
[_peripheralManager addService:_uuidService];
[_peripheralManager startAdvertising:#{CBAdvertisementDataServiceUUIDsKey: #[_uuidService.UUID],
CBAdvertisementDataLocalNameKey: #"UUID"}];
}

CoreBluetooth long characteristics CBATTErrorDomain Code=11 "The attribute is not long

I have a characteristic value which contains the large set of data (~200 Bytes)
Peripheral
_ch = [[CBMutableCharacteristic alloc] initWithType:_chUUID
properties:CBCharacteristicPropertyRead
value:nil
permissions:CBAttributePermissionsReadable ];
When this value is requested, the didRecieveRequest callback is called:
-(void) peripheralManager:(CBPeripheralManager *)peripheral didReceiveReadRequest:(CBATTRequest *)request {
if ([request.characteristic.UUID isEqual:_chUUID]) {
if (request.offset > _data.length) {
[_peripheralManager respondToRequest:request withResult:CBATTErrorInvalidOffset];
return;
}
else {
// Return the data
request.value = [_data subdataWithRange:NSMakeRange(request.offset, _data.length - request.offset)];
[_peripheralManager respondToRequest:request withResult:CBATTErrorSuccess];
}
}
This is is pretty much from Apple's example.
On the Central side, when didUpdateValueCorCharacteristic: callback is called, i get the error
Error Domain=CBATTErrorDomain Code=11 "The attribute is not long."
I know that I could use the Notify mechanism to chunk the data myself, as shown at the WWDC 2012. But that is not an option as I am not in charge of the Central code.
I would assume that didReceiveReadRequest: should be called more than once (with a increasing offset) as CB Framework should take care of the chunking, right? Do I miss something here?
Cheers

Resources