self.centralManager = [[RZBCentralManager alloc] init];
[self.centralManager scanForPeripheralsWithServices:@[CBUUID rzb_UUIDForHeartRateService] options:@{} onDiscoveredPeripheral:^(RZBScanInfo *scanInfo, NSError *error) {
    [self.centralManager stopScan];
    self.peripheral = scanInfo.peripheral;
    [self.peripheral rzb_addHeartRateObserver:^(RZBHeartRateMeasurement *measurement, NSError *error) {
        NSLog(@"%@", measurement);
    } completion:^(NSError *error) {
        if (error) {
            NSLog(@"Error=%@", error);
        }
    }];
}];

RZBPeripheral *peripheral = [self.centralManager peripheralForUUID:uuid];
[peripheral readCharacteristicUUID:[CBUUID rzb_UUIDForBatteryLevelCharacteristic]
                       serviceUUID:[CBUUID rzb_UUIDForBatteryService]
                        completion:^(CBCharacteristic *characteristic, NSError *error) {
                                   NSData *valueIActuallyWant = characteristic.value;
                        }];

[self enableNotifyForCharacteristicUUID:[CBUUID rzb_UUIDForBatteryLevelCharacteristic]
                            serviceUUID:[CBUUID rzb_UUIDForBatteryService]
                               onUpdate:^(CBCharacteristic *characteristic, NSError *error) {
                                   // New value is notified by the peripheral
                           } completion:^(CBCharacteristic *characteristic, NSError *error) {
                                   // Notification has been configured
                           }];

- (void)exampleOperations
{
    RZBPeripheral *peripheral = [self.centralManager peripheralForUUID:uuid];
    [peripheral rzb_addBatteryLevelObserver:^(NSUInteger batteryLevel, NSError *error) {
        // Update UI for the battery level.
    } completion:^(NSError *error) {
        // Completion indicating that the battery monitor has been set up.
    }];
    [peripheral rzb_readSensorLocation:^(RZBBodyLocation location) {
    }];
    [peripheral rzb_addHeartRateObserver:^(RZBHeartRateMeasurement *measurement, NSError *error) {
    } completion:^(NSError *error) {
    }];
}

    peripheral.connectionDelegate = self
    peripheral.maintainConnection = YES;
}

//
- (void)peripheral:(RZBPeripheral *)peripheral connectionEvent:(RZBPeripheralStateEvent)event error:(NSError *)error;
{
    if (event == RZBPeripheralStateEventConnectSuccess) {
        // perform any connection set up here that should occur on every connection
    }
    else {
        // The device is disconnected. maintainConnection will attempt a connection event
        // immediately after this. This default maintainConnection behavior may not be
        // desired for your application. A backoff timer or other behavior could be
        // implemented here.
    }
}

[RZBUserInteraction setTimeout:5.0];
[RZBUserInteraction perform:^{
    [self.peripheral rzb_fetchBatteryLevel:^(NSUInteger level, NSError *error) {
        // The error object could have status code RZBluetoothTimeoutError
    }];
}];

    [self.mockCentralManager fakeStateChange:CBManagerStatePoweredOn];
    // Triggers: - (void)centralManagerDidUpdateState:(CBCentralManager *)centralManager
    // Configures: centralManager.state == CBManagerStatePoweredOn

    [self.mockCentralManager fakeDisconnectPeripheralWithUUID:identifier
                                                        error:nil];
    // Triggers: - (void)centralManager:(CBCentralManager *)central didDisconnectPeripheral:(CBPeripheral *)peripheral error:(nullable NSError *)error
    // Configures: peripheral.state = CBPeripheralStateDisconnected

CBMutableService *batteryService = 
    [[CBMutableService alloc] initWithType:[CBUUID rzb_UUIDForBatteryService] primary:NO];
CBMutableCharacteristic *batteryCharacteristic = 
    [[CBMutableCharacteristic alloc] initWithType:[CBUUID rzb_UUIDForBatteryLevelCharacteristic]
                                       properties:CBCharacteristicPropertyRead | CBCharacteristicPropertyIndicate
                                            value:nil
                                      permissions:CBAttributePermissionsReadable];
batteryService.characteristics = @[batteryCharacteristic];

[self addService:batteryService];

__block typeof(self) welf = (id)self;
[self addReadCallbackForCharacteristicUUID:[CBUUID rzb_UUIDForBatteryLevelCharacteristic] handler:^CBATTError (CBATTRequest *request) {
    NSNumber *batteryNumber = welf.values[RZBBatteryLevelKey];
    uint8_t batteryLevel = [batteryNumber unsignedIntegerValue];
    request.value = [NSData dataWithBytes:&batteryLevel length:1];
    return CBATTErrorSuccess;
}];

- (void)setBatteryLevel:(uint8_t)level
{
    self.values[RZBBatteryLevelKey] = @(level);
    CBMutableCharacteristic *batteryCharacteristic = [self characteristicForUUID:[CBUUID rzb_UUIDForBatteryLevelCharacteristic]];

    NSData *value = [NSData dataWithBytes:&level length:1];
    [self.peripheralManager updateValue:value
                      forCharacteristic:batteryCharacteristic
                   onSubscribedCentrals:nil];
}

- (uint8_t)batteryLevel
{
    return [self.values[RZBBatteryLevelKey] unsignedIntegerValue];
}

// Update the battery level and send a notification to any central observing the battery level
device.batteryLevel = 88;

// Do this once at app load
RZBEnableMock(YES);

// Obtain the existing application CBCentralManager, which is really an RZBMockCentralManager since mocking is enabled.
CBCentralManager *centralManager = [[CBCentralManager alloc] init];

// Create a fake peripheral
self.fakePeripheral = [[RZBSimulatedDevice alloc] init];

// Setup the simulated central and the simulated connection
self.central = [[RZBSimulatedCentral alloc] initWithMockCentralManager:centralManager.mock];

[central addSimulatedDeviceWithIdentifier:[NSUUID UUID]
                        peripheralManager:self.fakePeripheral.peripheralManager];
self.connection = [central connectionForIdentifier:identifier]

// Disconnect or prevent connection.
self.connection.connectable = NO;
// ...runloop spins...

// Become connectable again
self.connection.connectable = YES;