Realizzare Accessori iOS con Bluetooth Low Energy e Arduino

Realizzare accessori iOS
con Bluetooth Low Energy e
Arduino
Fiore Basile
@ﬁbasile

Possibilità su iOS 5
•Cavo RedPark.com

•Adattatore presa audio

•ExternalAccessory.Framework

•Programma MFI

•Royalty

•Lungo processo di approvazione

•Diﬃcile per aziende piccole

A partire da iOS6

•E’ possibile realizzare accessori

•senza aderire a MFI

•senza usare hardware esterno

•BLE è supportato da

•iPhone 4S e superiori

•iPad Retina e iPad Mini

Caratteristiche
• Pensato per realizzare:

• dispositivi economici

• a basso consumo, durare anni con una pila

• che comunicano a distanza ravvicinata

• per brevissimi periodi di tempo

• Bluetooth 2.0 vs Bluetooth 4.0

• stesso nome ma tecnologia diversa e non compatibile

• alcuni moduli DUAL Mode supportano entrambi i
protocolli per aumentare la compatibilità

• i.e. Macbook Air, nuovi modelli

Comparazione
Bluetooth 2.0

Bluetooth 4.0

Dispositivi

Audio, Video, Tastiere,
Mouse, Altoparlanti

Sensori, Wearable

Connessioni

pairing

advertising

Banda

Ampia

Stretta 0.3 Mbps

Durata

lunga

breve, lo stretto necessario

Consumo!

Alto

Minimo

Bluetooth 2.0 vs 4.0
60

45

Mbps

30

15

0

versione 1.1 versione 2.0 versione 3.0 versione 4.0

Larghezza banda

Architettura

GATT
UART
Multiplex
Radio

Architettura
• Controller:

• device con una radio capace di comunicare sulla banda 2.4
Ghz

• contiene software necessario per gestire advertising, la
scansione e la gestione delle connessioni

• si integra con l’host tramite USB, SDIO, o UART

• Host
• funzionalità per fare multiplexing e gestire l’accesso alle
informazioni esportate dai vari devi

• L2CAP fornisce la gestione dei canali di comunicazione, il

security manager contiene un protocollo per la gestione del
pairing, calcolo di hash

Architettura
• Attribute protocol deﬁnisce i tipi di interazione

• richieste dal client al server

• risposte a una richiesta, dal server al client

• comandi che non prevedono risposta, inviati dal client al server

• notiﬁche dal server al client senza conferma

• indicazioni inviate dal server al client

• conferme inviate dal client al server come risposta ad
un’indicazione ricevuta

• Ogni attributo
• ha un indirizzo unico, un tipo e un valore associato.

• alcuni attributi possono essere in sola lettura

Ruoli
Generic Access Profile, definisce i ruoli

• Broadcaster – si limita all’advertising

• Observer – monitora gli advertisement, ma non può
connettersi

• Peripheral – esegue l’advertisement, consente la

connessione e può essere considerato come slave

• Central - ha il ruolo di master

• monitora gli advertisements

• avvia le connessioni

• può gestire ﬁno a tre slave contemporaneamente

Modello applicativo
• Characteristics
• identificate da un UUID

• ha un tipo e un valore

• può essere letta, scritta e
notificata

• Service
• identificato da un UUID

• raggruppa caratteristiche

• può contenere altri service

• Peripherial
• definisce un Profile, l’insieme
di service disponibili

• alcuni sono di default i.e.

• Device Info

Peripherial

Service
Characteristic

Descriptor

Characteristic

Descriptor

Service

Un esempio
Name: Current Time Service

Type: org.bluetooth.service.current_time

Assigned Number: 0x1805

Abstract:
This service defines how the current time can be exposed using the Generic
Attribute Profile (GATT).

!

Service Characteristics
org.bluetooth.profile.time

!

Mandatory properties
Read

Notify

https://developer.bluetooth.org/gatt/profiles/Pages/ProfilesHome.aspx

TI Sensor Tag
Ottima introduzione a BLE

• Accelerometro 3 assi

• Magnetometro 3 assi

• Giroscopio 3 assi

• Termometro ambiente +  
dispositivo

• Sensore umidità

• Barometro

• 33 Euro + IVA

CBPeripheral UUID
F0000000-0451-4000-B000-000000000000

TI Sensor TAG
Service

Characteristic

AA00 Termometro

AA01 Temperatura
AA02 On-Off

AA10 Accelerometro!

AA11 Accelerazione (3 byte)
AA12 On-off
AA13 Sample rate

AA20 Umidità!

AA21 Val. Umidità
AA22 On - off

AA30 Magnetometro

AA31 Campo magnetico
AA32 On - off
AA33 Sample rate

TI Sensor TAG
Service

Characteristic

AA40 Barometro

AA41 Pressione
AA42 On-off
AA43 Calibrazione

AA50 Giroscopio

AA51 Rotazione
AA52 On-off

Calcolo l’UUID della caratteristica Rotazione come
F000AA51-0451-4000-B000-000000000000

notify:ON Temperature

changed value: bytes Temperature

App
LightBlue
permette
di sfogliare
i servizi

Cos’è Arduino?
• Progetto open-hardware iniziato nel 2005

• Obiettivo: fornire alla community dei maker, dei ricercatori
e al mondo dell’educazione una piattaforma elettronica
per sperimentare e realizzare rapidamente prototipi

• Tre elementi principali:

• una serie di schede elettroniche con un microcontroller e una serie di ingressi e uscite

• un IDE che consente di scrivere software e caricarlo
sulla scheda

• una community, che fornisce software e

documentazione gratuita sulla piattaforma

Open hardware
•Arduino è open
hardware

•Chiunque può creare
il proprio clone non
uﬃciale

•Tutti i cloni

rimangono
compatibili con la
piattaforma

Scegliere la scheda
cpu, memoria, dimensioni,input

UNO

AVR 8bit, 14 digital IO pin, 6 analog input,
UART, SPI, I2C

Leonardo!

USB Host, 2 UART

Mega

54 digital IO, 16 analog, 4 UART

Pro mini - Nano

Meno porte, form-factor 2cm

Lilypad, Flora, Xadow

Wearable, da cucire, basso consumo

Yun

Linux MIPS + Wiﬁ: Internet of Things

Due, Tre!

CPU ARM, form factor compatibile

Cloni

Prezzo, funzionalità built-in aggiuntive

Shield

WIFI

MOTOR

TFT

GPS,
Midi,
Relé
etc
ETHERNET

GSM

Protocolli
Seriale

Bluetooth 4.0

I2C

USB Client e Host

Bluetooth 2.0

SPI

Ethernet

GPS

TWI

Wiﬁ

RF

CAN

Zigbee

Midi

Esempi
• Accelerazione

• Temperatura

• Pressione atmosferica

• Luce

• Colore

• Infarossi

• Magnetismo

• GAS

• Suono

• Resistenza

• Flessione

• Contatto

• Energia

• ….

Esempio
Lampeggiare
un led in base
all’intervallo
deﬁnito con un
potenziometro

Sketch Arduino
int sensorPin = A0; // Pin A0 di ingresso per il potenziometro
int ledPin = 13; // Pin D13 per accendere un LED
int sensorValue = 0; // Variabile che contiene il valore letto

!

void setup() {
// il pin del led è di OUTPUT
pinMode(ledPin, OUTPUT);
}

!

void loop() {
// leggiamo il valore
sensorValue = analogRead(sensorPin);
// accendiamo il pin associato al led
digitalWrite(ledPin, HIGH);
// sospendiamo il programma per sensorValue millisecondi:
delay(sensorValue);
// spegnamo il led:
digitalWrite(ledPin, LOW);
// sospendiamo il programma per sensorValue millisecondi:
delay(sensorValue);
}

Arduino Community
• Documentazione

• Download

• Forum

• Tutorial

• Progetti

http://playground.arduino.cc

CoreBluetooth.framework
• Equivalente del framework OSX 
IOBluetooth.framework

• Funzionalità BLE

• Scansione delle periferiche

• Connessione

• Discovery dei Service

• Discovery delle Characteristic dei Services

• Lettura e scrittura Characteristic

• Notiﬁca Characteristic

Modello
CBCentralManager

CBPeripheral
CBService
CBCharacteristic
Descriptor

Supporto iniziale

•CBCentralManager + Delegate

•CBPeripheral + Delegate

•CBService

•CBCharacteristic

•CBCharacteristicDescriptor

Novità
•Modifiche e semplificazioni alle API

•NSUUID vs CFUUIDRef

•Accesso più rapido alle periferiche già conosciute

•Tutti i device iOS supportati forniscono

•Time Service

•Battery Service

•Apple notification center service

•Introduzione di iBeacon

•CLBeaconRegion

•Introduzione di Apple Notification Center Service rende
possibile accesso al Notification Center

Esempio pratico
• FASE 1: Discovery di una Peripheral

• FASE 2: Connessione alla Peripheral

• FASE 3: Scansione dei Service

• FASE 4: Dump di Service e Characteristic Descriptor

• FASE 5: Lettura RSSI

• FASE 6: Lettura Valori Characteristic

• FASE 7: Notiﬁca Modiﬁche a Characteristic

• FASE 8: Scrittura Valore Characteristic

CBCentralManager

<CBCentralManagerDelegate>

- (id)initWithDelegate:!
(id<CBCentralManagerDelegate>)delegate !
queue:(dispatch_queue_t)queue !
options:(NSDictionary *)options
- (void)centralManagerDidUpdateState:!
(CBCentralManager *)central
central.state == !
CBCentralManagerStatePoweredOn

-(void)scanForPeripheralsWithServices:!
(NSArray *)serviceUUIDs !

Altrimenti 
ALERT 
BLE Non attivo!!

- (void)centralManager:(CBCentralManager*)c !
didDiscoverPeripheral:(CBPeripheral*)p  
advertisementData:(NSDictionary*)a 
RSSI:(NSNumber *)RSSI

CBCentralManager
- (void)connectPeripheral:!
(CBPeripheral *)peripheral !

CBPeripheral

<CBCentralManagerDelegate>

- (void)centralManager: 
(CBCentralManager*)c  
didConnectPeripheral: 
(CBPeripheral *)p

- setDelegate:

-(void)discoverServices:!
! (NSArray *)serviceUUIDs

CBPeripheralDelegate
- (void)peripheral:(CBPeripheral *)p !
didDiscoverServices:(NSError *)e

- (void)discoverCharacteristics: 
(NSArray *)characteristicUUIDs  
forService:(CBService *)service

MyBleController
@interface BLE : NSObject <CBCentralManagerDelegate,
CBPeripheralDelegate> {
}
!
@property (strong, nonatomic) CBCentralManager *manager;
@property (strong, nonatomic) CBPeripheral *peripheral;
@property (assign, nonatomic) BOOL connected;

CBCentralManager init & State
CBCentralManagerDelegate
- (void)initCentral
{
self.connected = NO;
    //Creando CBCentralManager iniziamo a ricevere con i metodi delegate
self.manager = [[CBCentralManager alloc] initWithDelegate:self queue:nil];
}

!

// Delegate
- (void)centralManagerDidUpdateState:(CBCentralManager *)central
{
/* central.state indica lo stato della radio Bluetooth
CBCentralManagerStateUnsupported, CBCentralManagerStateUnauthorized,
CBCentralManagerStatePoweredOff, CBCentralManagerStateUnknown
*/

!

   if (self.connected && central.state < CBCentralManagerStatePoweredOn) {
// Bluetooth disabilitato o rifiutato
        [self resetConnection];
   } else if (!self.connected
&& central.state == CBCentralManagerStatePoweredOn)
// Possiamo iniziare lo scan
        [self openConnection];
    }
}

Scan & scoperta periferiche
- (void)openConnection
{
    /* Inizia lo scan senza uno specifico service, per trovare 
tutte le peripheral. Passare un array di NSUUID per filtrare
in base a UUID servizio.
Le options ci permettono di continuare a ricevere gli
advertising delle peripheral già scoperte. (Consuma batteria) */
    [self.manager scanForPeripheralsWithServices:nil options:nil];
}
// Delegate
- (void)centralManager:(CBCentralManager *)central
didDiscoverPeripheral:(CBPeripheral *)peripheral
advertisementData:(NSDictionary *)advertisementData
        RSSI:(NSNumber *)RSSI
{
// Scoperta nuova peripheral
    if (peripheral.name == NULL) { return; }
    if (peripheral.identifier == NULL) { return; } // nuovo in iOS 7

!

    [self.manager stopScan];
     self.peripheral = peripheral; // Teniamo la reference evitiamo il
release
[self.manager connectPeripheral:peripheral options:nil];
}

Connessione
- (void)centralManager:(CBCentralManager *)central didConnectPeripheral:
(CBPeripheral *)peripheral
{
    // connessi alla periferica
// Diventiamo CBPeripheralDelegate della periferica
    [peripheral setDelegate:self];
// Iniziamo il discovery dei servizi
    [peripheral discoverServices:nil];
}
didFailToConnectPeripheral:(CBPeripheral *)peripheral
                 error:(NSError *)error
{
// connessione fallita
}
didDisconnectPeripheral:(CBPeripheral *)peripheral
                 error:(NSError *)error;
{
// connessione terminata
}

Discovery Servizi e Caratteristiche
CBPeripheralDelegate
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error
{

for (CBService *service in peripheral.services) {
        NSString *UUIDString = service.UUID.UUIDString; // New in iOS 7

!

/** iOS 6 way required bridging from Core Foundation
NSString *UUIDString = CFBridgingRelease(CFUUIDCreateString(NULL,
CFBridgingRetain(service.UUID))); **/


        NSLog(@“Discovered service %@: %@“, UUIDString, service.debugDescription]];

!
!

// Discovery Caratteristiche servizi

        [peripheral discoverCharacteristics:nil forService:service];
    }
}
- (void)peripheral:(CBPeripheral *)peripheral didDiscoverCharacteristicsForService:
(CBService *)service error:(NSError *)error
{
// Caratteristiche trovate
    for (CBCharacteristic *characteristic in service.characteristics) {
        NSString *cUUIDString =characteristic.UUID.UUIDString;

        NSLog(@“ %@: %@", cUUIDString, characteristic.debugDescription));
    }
}

Identita’ servizi e caratteristiche
-(CBService *) findServiceFromUUID:(NSUUID *)UUID p:(CBPeripheral *)p
{
for(int i = 0; i < p.services.count; i++)
{
CBService *s = [p.services objectAtIndex:i];
if ([s.UUID.UUIDString isEqualToString:UUID.UUIDString])
return s;
}
return nil; //Servizio non disponibile
}
-(CBCharacteristic *) findCharacteristicFromUUID:(CBUUID *)UUID
service:(CBService*)service
{
for(int i=0; i < service.characteristics.count; i++)
{
CBCharacteristic *c = [service.characteristics
objectAtIndex:i];
if ([c.UUID.UUIDString isEqualToString:UUID.UUIDString])
return c;
}
return nil; //Caratteristica non disponibile
}

RSSI
(Received signal strength indication)
- (void) updateRSSI {

!

// richiesta lettura RSSI
if (self.peripheral != nil && self.connected) {

!
!

[self.peripheral readRSSI];
}

!

}
- (void)peripheralDidUpdateRSSI:(CBPeripheral *)peripheral
error:(NSError *)error
{

!
!
!

}

// potenza del segnale ottenuta i.e. -40db = 1 metro 
// —46db = 2metri etc
int rssi = peripheral.RSSI.intValue;

Lettura valore caratteristica
-(void) readValue: (NSUUID *)serviceUUID characteristicUUID:(NSUUID
*)characteristicUUID p:(CBPeripheral *)p
{
CBService *service = [self findServiceFromUUID:serviceUUID p:p];
if (!service)
{
// non trovato
return;
}
CBCharacteristic *characteristic = [self
findCharacteristicFromUUID:characteristicUUID service:service];
if (!characteristic)
{
// Non trovata
}
}

[p readValueForCharacteristic:characteristic];

Abilita Notiﬁche caratteristica
-(void) notification:(CBUUID *)serviceUUID characteristicUUID:(CBUUID
*)characteristicUUID p:(CBPeripheral *)p on:(BOOL)on
{
if (!service)
{
// non trovato
return;
}
{
// non trovata
return;
}
[p setNotifyValue:ON forCharacteristic:characteristic];
}

Conferma modiﬁca ﬂag & ricezione dati
- (void)peripheral:(CBPeripheral *)peripheral
didUpdateNotificationStateForCharacteristic:(CBCharacteristic
*)characteristic error:(NSError *)error
{
if (!error)
{
//
flag modificato, ok
}
else {// errore}
}
- (void)peripheral:(CBPeripheral *)peripheral
didUpdateValueForCharacteristic:(CBCharacteristic *)characteristic error:
(NSError *)error
{
if (!error)
{
// leggiamo n byte in base alla caratteristica
NSString uuidString = characteristic.UUID.UUIDString;
int dataLen = characteristic.value.length;
NSData* data = characteristic.value;
// abbiamo ricevuto dataLen bytes
}
else {
// errore }
}

Scrittura valore Caratteristica
-(void) writeValue:(CBUUID *)serviceUUID characteristicUUID:(CBUUID
*)characteristicUUID p:(CBPeripheral *)p data:(NSData *)data
{
if (!service)
{
// non trovato
}
{
// non trovata
}

!
}

// Scrivo senza richiedere una conferma della modifica con
CBCharacteristicWriteWithoutResponse
// CBCharacteristicWriteWithResponse chiama invece il delegate
// peripheral:didWriteValueForCharacteristic:error:
[p writeValue:data forCharacteristic:characteristic
type:CBCharacteristicWriteWithoutResponse];

YmsCoreBluetooth
• Framework open source per sviluppare applicazioni BLE

• Basato sui Blocks

• Codice di esempio per l’uso del TI Tag Sensor

• Disponibile su

http://kickingvegas.github.io/YmsCoreBluetooth/

YmsCoreBluetooth
!•! YMSCBCentralManager da estendere !
! scansione e caricamento peripheral!
!•! YMSCBPeripheral da estendere!
! connessione e disconnessione, discovery servizi!
!•! YMSCBService da specializzare in n sottoclassi!
!! discovery characteristic, gestione notiﬁche!
!•! YMSCBCharacteristic da specializzare in sottoclasse!
! gestione stato notiﬁche, scrittura, lettura, descriptor!
! interpretazione dei dati!
!•! YMSCBDescriptor!
!! lettura e scrittura valori

Motivazioni
• Gli iBeacon consentono di creare servizi di localizzazione
precisi in spazi ristretti

• Ogni iBeacon trasmette la propria presenza

• Le app possono identificare iBeacon vicini o distanti in
un’area

• Il processo può essere attivato in una specifica Location

• A ciascun iBeacon può corrispondere

• Una notifica

• Un contenuto

• Un biglietto Passbook, etc

Esempio
• App Supermercato
• Catena di supermercati

com.app.supermarket

Identificatore Unico

!

• Supermercato specifico

Indentificatore Major

!

• Banco Salumeria

Identificatore Minor

!
!

• Il beacon ci permette di sapere esattamente dove ci
troviamo all’interno del supermercato

iBeacon

Unico per l’app
uguale per tutti gli iBeacon

iBeacon
UUID

Identificatore x location
es. milano, pisa

Identificatore

Es. Identificatore Negozio

Major

Es. Identificatore Zona

Minor

iBeacon trasmissione
#import <CoreBluetooth/CoreBluetooth.h>
#import <CoreLocation/CoreLocation.h>

!

@interface IBeaconTransmitter ()
@property (nonatomic, retain) CLBeaconRegion *beaconRegion;
@property (nonatomic, retain) CBPeripheralManager *manager;
@end

/* Identificativi */
NSUUID *uuid = [[NSUUID alloc] initWithUUIDString: 
@"AAAA-BBBB-CCCC-DDDD"];
NSString *identifier = @"MyBeacon";

!

//Region di interesse

!

self.beaconRegion = [[CLBeaconRegion alloc]
initWithProximityUUID:uuid identifier:identifier];
self.manager = [[CBPeripheralManager alloc] initWithDelegate:self
queue:nil];

iBeacon Trasmissione - 2
#pragma mark - CBPeripheralManagerDelegate

//CBPeripheralManager callback, il manager è pronto per la connessione

!

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

  // default power
  // possiamo dare un valore diverso per limitare l’advertising

!

NSDictionary *payload = [beaconRegion
peripheralDataWithMeasuredPower:nil];

  //Start advertising
  [manager startAdvertising:payload];
}

iBeacon - Monitoring
#import <CoreLocation/CoreLocation.h>

/* Stesso UUID di prima */

!

NSUUID *uuid = [[NSUUID alloc] initWithUUIDString:@"AAAA-BBBB-CCCCDDDD"];

!

NSString *identifier = @"MyBeacon";

!

//Definiamo la region dove cercare i beacon con questi dati

!

CLBeaconRegion *beaconRegion = [[CLBeaconRegion alloc]
initWithProximityUUID:uuid identifier:identifier];

!

// Avvia il monitoring

!

CLLocationManager *manager = [[CLLocationManager alloc] init];

!

[manager setDelegate:self];

!

[manager startMonitoringForRegion:beaconRegion];

iBeacon Monitoring - 2
#pragma mark - CLLocationManagerDelegate Methods

//Callback se entriamo in una region di interesse
//Beacon in vista
- (void)locationManager:(CLLocationManager *)manager didEnterRegion:
(CLRegion *)region
{
  if ([region isKindOfClass:[CLBeaconRegion class]]) {
    [manager startRangingBeaconsInRegion:(CLBeaconRegion *)region];
  }
}

//Callback quando usciamo da una region di interesse
//Nessun beacon in vista
- (void)locationManager:(CLLocationManager *)manager didExitRegion:
(CLRegion *)region
{
  if ([region isKindOfClass:[CLBeaconRegion class]]) {
    [manager stopRangingBeaconsInRegion:(CLBeaconRegion *)region];
  }
}

iBeacon Monitoring - 3
// Log delle trasmissioni dei beacon
- (void)locationManager:(CLLocationManager *)manager
didRangeBeacons:(NSArray *)beacons
               inRegion:(CLBeaconRegion *)region
{
  //Verifichiamo la distanza dal iBeacon
  CLBeacon *beacon = [beacons objectAtIndex:0];

  switch (beacon.proximity) {
    case CLProximityImmediate:
      NSLog(@“Immediatamente vicino");
      break;
    case CLProximityNear:
      NSLog(@“Quasi vicino");
      break;
    default:
      NSLog(@“Visible ma distante");
      break;
  }
}

Apple Notiﬁcation Center Service

Apple Notification Center Service
• Sostituisce il Notification Profile di BLE con una versione
proprietaria

• Consente di monitorare tramite BLE le notifiche delle
applicazioni iOS

• Permette di realizzare “Display” e comportamenti legati alle
notifiche iOS

• Scenari:

• Arrivo di una notifica

• Modifica di una notifica

• Annullamento di una notifica

Motivazioni
• Tramite l’Apple Notification Center Service e’
possibile accedere alle notifiche dal Device

• Possiamo visualizzare le notifiche o rispondere con
output e azioni

• E’ possibile realizzare accessori che estendono il
device con ad esempio con

• schermi aggiuntivi, luci, vibrazione, motori, etc…

Servizio e caratteristiche
• Service  

UUID 7905F431-B5CE-4E99-A40F-4B1E122D00D0 
 
Caratteristiche

• Notification Source: Obbligatorio  

UUID 9FBF120D-6301-42D9-8C58-25E699A21DBD (notifiable)  
da monitorare per ricevere le notifiche

• Control Point:

Opzionale 
UUID 69D1D8F3-45E1-49A8-9821-9BBDFDAAD9D9  
(writeable with response)  
da usare per richiedere info aggiuntive

• Data Source: Opzionale 

UUID 22EAC6E9-24D6-4BB5-BE44-B36ACE7C7BFB (notifiable) 
da monitorare per ricevere le info aggiuntive

Notification Source
• I dati relativi alle notifiche
contengono:

• Il tipo di notifica (nuova, modifica,
annulla)

• Flag notifica (ad. esempio importante)

• Categoria della notifica (Chiamata in

entrata, persa, etc, Email, News,
Social, Location Entertainment, etc)

• Numero notifiche

• UUID Notifica utile per recuperare
attributi della notifica da Control
Point

Notifica
Tipo
Flag
Categoria

Altri attributi
• Attributi Notiﬁca

• App id applicazione

• Titolo notiﬁca

• Messaggio

• Attributi App

• Nome app

Arduino e BLE
• Supporto tramite shield

• RedbearLab BLE Shield

• Dr. Knoll BLE Shield

• Richiedono librerie

aggiuntive per Arduino

Arduino e BLE
Supporto tramite un modulo esterno

• MicroController
integrato

• Si connette

direttamente alla
porta Seriale di
Arduino

• Non richiede librerie
aggiuntive

• Consente di

aggiornare il
ﬁrmware

• RedbearLab BLE MINI
• Aggiungere supporto a progetti
Wearable, Etc

• Supporta iBeacon

• Non supporta al
momento ANCS

BLE Firmata
• Libreria Arduino fornita con BearLab BLE Shield

• https://github.com/RedBearLab/Release/raw/master/BLEShield/
BLEShield_Library_v1.0.2.zip

• Carichiamo su Arduino BLEFirmata.pde tramite l’IDE

• Possiamo accedere tramite BLE a tutti gli input e gli output di Arduino
dall’app iOS BLE Arduino

Protocollo

ﬁrmata.org

formato

MIDI

• BLEFirmata.pde

BLE Shield - Servizi
• Unico Service 

UUID "713D0000-503E-4C75-BA94-3148F18D941E"

• Due caratteristiche TX, RX

• Leggiamo i dati dallo Shield attivando la notiﬁca sulla caratteristica RX 
713D0002-503E-4C75-BA94-3148F18D941E

• Scriviamo i dati sullo Shield aggiornando il valore della caratteristica TX 
713D0003-503E-4C75-BA94-3148F18D941E

notify:ON RX
write: bytes TX
changed value: bytes RX

BLE Chat - Arduino Code
#include <Arduino.h>
#include <SPI.h>
#include "ble.h"

!

unsigned char buf[16] = {0};
unsigned char len = 0;

!

void setup()
{
// protocollo SPI per  
// comunicare con lo shield
SPI.setDataMode(SPI_MODE0);
SPI.setBitOrder(LSBFIRST);
SPI.setClockDivider(SPI_CLOCK_DIV16
);
SPI.begin();
ble_begin();
// monitor seriale arduino
Serial.begin(57600);

void loop()
{
// leggi dal canale ble
while ( ble_available() )
Serial.write(ble_read());
// leggo dalla seriale di arduino  
// per 16 bytes o fino a n
while ( Serial.available() )
{
unsigned char c = Serial.read();
if (c != 0xD)
{
if (len < 16)
buf[len++] = c;
}
else
{
// scrivo il buffer sullo
shield BLE
for (int i = 0; i < len; i++)
ble_write(buf[i]);
len = 0;
}
}

}
}

ble_do_events();

BLE Chat - iOS Code
Connessione e discovery come esempio BLE Dump
// Attivo la notifica sul service RX
!
-(void) enableReadNotification:(CBPeripheral *)p
{
CBUUID *uuid_service = [[NSUUID alloc]
initWithUUIDString:@BLE_DEVICE_SERVICE_UUID];
CBUUID *uuid_char = [[NSUUID alloc] initWithUUIDString:
@BLE_DEVICE_RX_UUID];

}

[self notification:uuid_service
characteristicUUID:uuid_char p:p on:YES];

BLE Chat - iOS Code
Scrivo sulla caratteristica TX, NSData di max 16 Byte alla volta

-(void) write:(NSData *)d
{
CBUUID *uuid_service = [[NSUUID alloc]
initWithUUIDString:
@BLE_DEVICE_SERVICE_UUID];
CBUUID *uuid_char = [[NSUUID alloc]
initWithUUIDString:
@BLE_DEVICE_TX_UUID];
[self writeValue:uuid_service
characteristicUUID:uuid_char
p:activePeripheral data:d];
}

BLE Chat - Arduino Code
!
#include <Arduino.h>
!
!
unsigned char buf[16] = {0};
unsigned char len = 0;
!
void setup()
{
// ble mini sulla
// seconda seriale
Serial1.begin(57600);

}
!

// monitor seriale arduino
Serial.begin(57600);

void loop()
{
// leggi dal canale ble
while ( Serial1.available() )
Serial.write(Serial1.read());
// leggo dalla seriale di arduino  
// per 16 bytes o fino a n
while ( Serial.available() )
{
unsigned char c = Serial.read();
if (c != 0xD)
{
if (len < 16)
buf[len++] = c;
}
else
{
// scrivo sullo shield BLE
for (int i = 0; i < len; i++)
Serial1.write(buf[i]);
len = 0;
}
}
}

BLE Mini Framework iBeacon
RBL_SERVICE_UUID
RBL_CHARACTERISTIC_IBEACON_UUID
RBL_CHARACTERISTIC_MAJOR_UUID
RBL_CHARACTERISTIC_MINOR_UUID
RBL_CHARACTERISTIC_POWER_UUID

!
!

@"B0702880-A295-A8AB-F734-031A98A512DE"
@"B0702881-A295-A8AB-F734-031A98A512DE"
@"B0702882-A295-A8AB-F734-031A98A512DE"
@"B0702883-A295-A8AB-F734-031A98A512DE"
@"B0702884-A295-A8AB-F734-031A98A512DE"

Ci consentono di impostare via BLE quali saranno i valori per
Identiﬁer, UUID, MAJOR, MINOR, POWER ad es.
!
-(void) writeUUID:(NSData *)uuid_bytes
{
CBUUID *uuid_service = [[NSUUID alloc] initWithUUIDString:
@RBL_SERVICE_UUID];
CBUUID *uuid_char = [[NSUUID alloc] initWithUUIDString:
@ RBL_CHARACTERISTIC_IBEACON_UUID];
[self writeValue:uuid_service characteristicUUID:uuid_char
p:activePeripheral data:d];

!

}

Concludendo
• Il firmware custom consente di realizzare

• nuovi profili

• nuovi servizi

• nuove caratteristiche

• Purtroppo sono necessari SDK proprietari per scrivere un
nuovo firmware

• Per la maggior parte dei casi bastano le caratteristiche
esistenti

•

notifica RX e scrittura TX

Creare un protocollo
• Dimensione dei dati limitata (max
16 byte alla volta)

• Capace di gestire disconnessioni
frequenti

• Errori di trasmissione, pacchetti
incompleti

• Facile debug 
 

Esempi

• Firmata -> Protocollo Midi

• MQTT

• Protocollo ad hoc, Testo semplice

Da costruire
sulle
caratteristiche
RX / TX
dei moduli
BLE

Firmata
/* This protocol uses the MIDI message format!
* !
*
MIDI
!
* type
command channel
first byte
second byte !
*----------------------------------------------------------------------------!
* analog I/O message
0xE0
pin #
LSB(bits 0-6)
MSB(bits 7-13)!
* digital I/O message
0x90
port
LSB(bits 0-6)
MSB(bits 7-13)!
* report analog pin
0xC0
pin #
disable/enable(0/1)
- n/a -!
* report digital port
0xD0
port
disable/enable(0/1)
- n/a -!
*!
* sysex start
0xF0
!
* set pin mode(I/O)
0xF4
pin # (0-127)
pin state(0=in)!
* sysex end
0xF7
!
* protocol version
0xF9
major version
minor version!
* system reset
0xFF!
*!
*/

comando 0xE0

pin

LSB valore

MSB valore

Sensori
Arduino

• Parsing comandi iOS

• Gestione comandi:

• on / off sensore

• abilita / disabilita invio
pacchetti dati

• Lettura Dati dal Sensore

• Scrittura Pacchetto Dati

iOS

• On / Off Sensore

• Abilita Notifiche Valore
Sensore

• Parsing Pacchetto dati
Sensore

• Visualizza Dati Sensore

Smartwatch
Arduino



•

on / oﬀ sensore

iOS


Sensore

• abilita / disabilita invio pacchetti


• visualizza bitmap


• Invio messaggi sul display
• Invio notiﬁche sul display

dati

• visualizza messaggio testo
• reset



• Gestione del display

Sensore

Controllo remoto
• 2 Motori

indipendenti
• Accelerometro
• Magnetometro
• Sensori ad
infrarossi
• Ultrasuoni

Controllo Remoto
Arduino




pacchetti dati



• Gestione dei motori

iOS


Sensore

Sensore


• Invio velocita’ e angolo di
sterzata

Controller per App
Arduino



pacchetti dati



iOS

Sensore

Sensore

• Gestione input sull’app

Riepilogo
• Grazie all’integrazione tra Arduino e iOS è possibile:

• utilizzare sensori di ogni tipo e elaborare i dati in
applicazioni iOS

• pilotare robot e veicoli di vario tipo

• realizzare controller per le applicazioni iOS

• creare applicazioni context-sensitive grazie a iBeacon

• Esistono limitazioni sulla piattaforma Bluetooth 4.0 non è
ancora ampiamente diﬀusa

• Il costo degli adattatori è ancora elevato

Wearable Computing
Soft circuits
Internet of Things
UAV
Ubiquitous Computing

Riepilogo
• Col tempo si diﬀonderanno moltissimi tipi di accessori

• da indossare

• integrati negli oggetti di uso quotidiano

• nelle auto

• negli elettrodomestici

• La possibilità di reagire all’ambiente circostante creerà nuovi
tipi di app

• reti personali, domotica, eventi, advertising,

• luoghi pubblici, grande distribuzione, logistica

• droni, robot

Grazie!
!

contatti: 
Fiore Basile
@ﬁbasile
ﬁbasile.github.io

Realizzare Accessori iOS con Bluetooth Low Energy e Arduino

Recommandé

Recommandé

Contenu connexe

Similaire à Realizzare Accessori iOS con Bluetooth Low Energy e Arduino

Similaire à Realizzare Accessori iOS con Bluetooth Low Energy e Arduino (20)

Realizzare Accessori iOS con Bluetooth Low Energy e Arduino