Practical Core Bluetooth in IoT & Wearable projects @ AltConf 2016

Practical Core Bluetooth
in IoT & Wearable projects
Shuichi Tsutsumi @shu223
AltConf 2016 - San Francisco

iOS-10-Sampler
https://github.com/shu223

Overview
• Basics of Core Bluetooth
• Practical Core Bluetooth
Based on my experience!

Bluetooth Low Energy (BLE)
• Wireless technology

- no network infrastructure required

Wi-Fi

BLE

• Low energy
• NOT compatible with Classic BT

• Low energy
• Uses 2.4 GHz radio frequencies

• Low energy
• Marketed by the Bluetooth SIG

• Low energy
• Marketed by the Bluetooth SIG
• etc…

The most important thing
for
iOS developers

The API ‘Core Bluetooth’
is open for developers

The API ‘Core Bluetooth’
is open for developers
• API for Classic BT is NOT open.
- Requires MFi certification.

BLE is almost the ONLY way
to enable iOS apps to communicate
with external hardware
without infrastructure or MFi.

Moff Band Moff App
BLE Connection

Moff Band Moff App
BLE Connection
Sensors
- Gyroscope
- Accelerometer

Moff Band Moff App
Sensor Data
BLE Connection
Sensors
- Gyroscope
- Accelerometer

Moff Band Moff App
Sensor Data
BLE Connection
Sensors
- Gyroscope
- Accelerometer
Analyze sensor data

Moff Band Moff App
Sensor Data
BLE Connection
Sensors
- Gyroscope
- Accelerometer
Analyze sensor data
Recognize
- Gesture
- Posture

Moff Band Moff App
Sensor Data
BLE Connection
Sensors
- Gyroscope
- Accelerometer
Analyze sensor data
Recognize
- Gesture
- Posture
Play sounds

Sensor Data
BLE Connection
How is sensor data sent with Core Bluetooth?

Step 1. Scan: Search for nearby BLE devices

Step 1. Scan
Advertise
: Search for nearby BLE devices

Scan
Step 1. Scan
Advertise

Scan
Step 1. Scan
Advertise
centralManager.scanForPeripheralsWithServices(nil, options: nil)

Scan
Step 1. Scan
Advertise
Discover

Scan
Step 1. Scan
Advertise
Discover
func centralManager(central: CBCentralManager,
didDiscoverPeripheral peripheral: CBPeripheral,
advertisementData: [String : AnyObject],
RSSI: NSNumber!)
{
print(“Discovered a BLE device!”)
}

Scan
Step 1. Scan
Advertise
Discover
RSSI: NSNumber!)
{
}
Central

Scan
Step 1. Scan
Advertise
Discover
RSSI: NSNumber!)
{
}
Peripheral Central

Connect
Step 2. Connect
centralManager.connectPeripheral(peripheral, options: nil)

Connect
Step 2. Connect
centralManager.connectPeripheral(peripheral, options: nil)
didConnectPeripheral peripheral: CBPeripheral)
{
print(“Connected!”)
}

Step 3. Subscribe: Ready to receive data

GATT = Generic Attribute Profile

Moff Service
xx Service

Moff Service
xx Service
Button Characteristic
xx Characteristic
Sensor Characteristic

Moff Service
xx Service
xx Characteristic
Subscribe
(Request to be notified)

Moff Service
xx Service
xx Characteristic
Subscribe
(Request to be notified)
peripheral.setNotifyValue(true, forCharacteristic: c)

Step 4. Notify
Moff Service
xxxx Characteristic

Step 4. Notify
Moff Service
xxxx Characteristic
Update the value

Step 4. Notify
Notify
subscribers
Moff Service
xxxx Characteristic
Update the value

Step 4. Notify
Notify
subscribers
Moff Service
xxxx Characteristic
Update the value
func peripheral(peripheral: CBPeripheral,
didUpdateValueForCharacteristic characteristic: CBCharacteristic,
error: NSError?)
{
print(“Received sensor data!”)
}

Hardware Side?
I’m sorry, I don’t know…

BLE
Firmware Engineer iOS Engineer

Hardware Projects
I’ve worked on
as an iOS engineer

Wearable Walkie-Talkie
‘BONX’

Group conversation system with VoIP

- Detects the human voice

- Cuts out all background noise

- Cuts out all background noise
→ Can be used even in areas with poor coverage!

Printable Open-Source Humanoid “PLEN2”

Music for the Deaf
Daito Manabe/Motoi Ishibashi/Teruoka Masaki/Shuichi Tsutsumi x SOUL FAMILY

Music for the Deaf
iPhone

Music for the Deaf
Electronic Stimulation DeviceiPhone

Music for the Deaf
Commands
Electronic Stimulation DeviceiPhone

GATT to send sensor data
Foo Service
Sensor Data Characteristic
UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
Bar Service
xx Characteristic
Properties: Notify
Value: acc x, acc y, acc z, gyro x, gyro y, gyro z (2bytes for each)
xx Characteristic

GATT to send button interactions
Foo Service
Button Control Characteristic
Properties: Notify
Value: 0x01 or 0x00

Foo Service
Properties: Notify
Value: 0x01 or 0x00
Button interactions

Foo Service
Properties: Notify
Value: 0x01 or 0x00
Button interactions
0x01: Pushed
0x00: Released

GATT for remote control
Foo Service
Remote Control Characteristic
Properties: Write
Value: Horizontal (-100 ~ 100), Vertical (-100 ~ 100)

GATT for remote control
Foo Service
Remote Control Characteristic
Properties: Write
Value: Horizontal (-100 ~ 100), Vertical (-100 ~ 100)
values

GATT for generic commands
Electronic Stimulation Control Characteristic
Properties: Write
Value: 1 byte

Properties: Write
Value: 1 byte
4 Commands:
- Change the pulse frequency
- Change the electric current
- Right channels on/off
- Left channels on/off

Properties: Write
Value: 1 byte
High-order 2 bits
- 00: Change the pulse frequency
- 01: Change the electric current
- 10: Left channels on/off
- 11: Right channels on/off

How to define GATT
1. Create UUID for the service & characteristic

How to define GATT
$ uuidgen
CEEA31BC-BEAC-4A78-B7ED-FC96B6254D4C

How to define GATT
2. Define the properties (Read, Notify, Write, etc.)
$ uuidgen

How to define GATT
Peripheral → Central: Notify  
Central → Peripheral: Write
$ uuidgen

How to define GATT
3. Define the value format
$ uuidgen

How to define GATT
3. Define the value format
Usually limited to 20 bytes
$ uuidgen

Reference:
GATT profiles by Bluetooth SIG

Background behaviors on iOS
• Very limited
- Listening to music
- Getting location data
- Downloading data

If BLE didn’t work in the
background…

You would have to always keep the app
in the foreground, while snowboarding!

You would have to launch the app
whenever you go driving!

What functions can be used
in the background?

in the background?
• Scanning peripherals

in the background?
• Connecting with peripherals

in the background?
• Reading characteristics’ value

in the background?
• Writing characteristics’ value

in the background?
• Receiving notifications

in the background?
• Receiving notifications
Almost all functions can be used
even in the background!

How to support
background mode

Limitations
• Longer intervals for scanning

Limitations
• Must explicitly specify one or more services to scan

Limitations
• CBCentralManagerOptionShowPowerAlertKey option is
ignored

Limitations
• CBCentralManagerOptionShowPowerAlertKey option is
ignored
Resources
- Core Bluetooth Programming Guide
- Core Bluetooth Framework Reference (also in headers)

If the app in the background
is killed by the system…

State Preservation and Restoration

The system takes over the BLE tasks
even after the app is killed.

- Preserves the state of the app’s central managers and
continues the BLE tasks on their behalf.

- Relaunches the app into the background and calls the
corresponding delegate method.

- Relaunches the app into the background and calls the
corresponding delegate method.
→ The app can handle BLE events!

• The app is killed by the system

• The user pushes the button on the
peripheral device

peripheral device
• The system receives the notification

peripheral device
• The app is relaunched in the BG and the
delegate method is called.

error: NSError?)
{
print(“Received the characteristic data!”)
}
peripheral device

error: NSError?)
{
print(“Received the characteristic data!”)
}
peripheral device
The app can process the button interaction!

Implementation
• Add an option when initializing the
CBCentralManager object.
let options = [
CBCentralManagerOptionRestoreIdentifierKey: "somekey"
]
centralManager = CBCentralManager(
delegate: self,
queue: queue,
options: options)

Implementation
• Implement the delegate method which is called when
the app is restored.
willRestoreState dict: [String : AnyObject])
{
print("Restored")
}

Testing the restoration
• Kill the app as if it was killed by the iOS
kill(getpid(), SIGKILL);

How to test
without HW prototypes

Did the HW prototypes exist when develop the apps?
Projects HW prototypes existed?
Moff YES
WHILL NO
BONX NO
SmartDrive YES
PLEN2 NO
Music for the Deaf NO

Development Kit
BLE Module
Display

Development Kit
BLE Module
Display
USB interface

Development Kit
BLE Module
Display
USB interface
Battery box

Development Kit
Can start development without
creating a circuit ourselves
BLE Module
Display
USB interface
Battery box

Horizontal (-100~100) / Vertical (-100~100)
Development Kit App
BLE

Emulator App
• Develop another iOS app as the
alternative to the peripheral
device

Emulator App
device
• Use CBPeripheralManager

Emulator App
device
• Use CBPeripheralManager
• Easier for iOS engineers

Multi-Function Control
• Single Tap
• Double Tap
• Long Press
• Very Long Press
=

Can’t find the peripheral
Scan
?

• Connection dropped
• Can’t discover services or characteristics

• Fail to write

• Fail to write
• Incorrect characteristic values

• Fail to write
• Incorrect behaviors in the background

• Fail to write
• Incorrect behaviors in the background
• etc…

Identify which side
the problem is on
Is the problem on the central side or on the peripheral side?
→ Compare with another iOS app like ‘LightBlue’

• Scanning, but can’t find the peripheral device

Scan

Scan
but ‘didDiscover’
method isn’t called

• Scan with another iOS app
Scan

• Scan with another iOS app
Scan
Discovered peripherals

Can’t connect, etc.
Connect
Services & Characteristics

Bluetooth Explorer
macOS app made by Apple

Low Energy Devices
Scan, Connect

Low Energy Devices
Scan, Connect
Details of services and characteristics

Low Energy Devices
Scan, Connect
Details of services and characteristics
Write, Read, Subscribe

func centralManager(
central: CBCentralManager,
RSSI: NSNumber!)
{
print(advertisementData)
}

RSSI: NSNumber!)
{
}
Filtered by iOS!

RSSI: NSNumber!)
{
}
Filtered by iOS!
→ Can’t see all of the advertisement data

RSSI: NSNumber!)
{
}
Filtered by iOS!
→ Can’t see all of the advertisement data
e.g. Can’t see the ‘Manufacture Data’ field of iBeacon

Not filtered →Can see the ‘Manufacture Data’ field of iBeacon

Packet Logger
macOS app made by Apple

How to get
Download ‘Hardware IO Tools for Xcode’

Not enough devices when submitting

Videos for review
• Show how the app works with the peripheral device

Videos for review
• Show how the app works with the peripheral device
• Not need to be cool!

• Shoot with iPhone
• Edit with iMovie

Recap
• What is Bluetooth Low Energy?

Recap
• Basics of Core Bluetooth with an actual product

Recap
• Practical Core Bluetooth with specific examples

Recap
- Defining GATT

Recap
- Defining GATT
- Defining background behaviors

Recap
- Defining GATT
- Testing without HW prototypes

Recap
- Defining GATT
- Troubleshooting

Recap
- Defining GATT
- Troubleshooting
- App Review

func centralManagerDidUpdateState(_ central: CBCentralManager) {
print("state: (central.state)")
}

private var centralManager: CBCentralManager!
override func viewDidLoad() {
super.viewDidLoad()
centralManager = CBCentralManager(delegate: self, queue: nil)
}
From

private let centralManager = CBCentralManager()
super.viewDidLoad()
centralManager.delegate = self
}
private var centralManager: CBCentralManager!
super.viewDidLoad()
centralManager = CBCentralManager(delegate: self, queue: nil)
}
From
To

Thank you!
Shuichi Tsutsumi - iOS Freelancer
• Twitter: @shu223
• GitHub: shu223
• Blog: https://medium.com/@shu223/
• Email: shuichi0526@gmail.com

Practical Core Bluetooth in IoT & Wearable projects @ AltConf 2016

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (20)

Similar to Practical Core Bluetooth in IoT & Wearable projects @ AltConf 2016

Similar to Practical Core Bluetooth in IoT & Wearable projects @ AltConf 2016 (20)

More from Shuichi Tsutsumi

More from Shuichi Tsutsumi (20)

Recently uploaded

Recently uploaded (20)

Practical Core Bluetooth in IoT & Wearable projects @ AltConf 2016