Realizzare Accessori iOS con Bluetooth Low Energy e Arduino
Upcoming SlideShare
Loading in...5
×
 

Realizzare Accessori iOS con Bluetooth Low Energy e Arduino

on

  • 2,403 views

Slide del talk "Realizzare Accessori iOS con Bluetooth Low Energy e Arduino" tenuto durante la conferenza #pragma mark del 26 Ottobre 2013

Slide del talk "Realizzare Accessori iOS con Bluetooth Low Energy e Arduino" tenuto durante la conferenza #pragma mark del 26 Ottobre 2013

Statistics

Views

Total Views
2,403
Views on SlideShare
1,984
Embed Views
419

Actions

Likes
9
Downloads
62
Comments
0

3 Embeds 419

http://pragmamark.org 355
http://fibasile.github.io 33
https://twitter.com 31

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Realizzare Accessori iOS con Bluetooth Low Energy e Arduino Realizzare Accessori iOS con Bluetooth Low Energy e Arduino Presentation Transcript

    • Realizzare accessori iOS con Bluetooth Low Energy e Arduino Fiore Basile @fibasile
    • Accessori per iOS
    • Esempi
    • Possibilità su iOS 5 •Cavo RedPark.com •Adattatore presa audio •ExternalAccessory.Framework •Programma MFI •Royalty •Lungo processo di approvazione •Difficile 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
    • Bluetooth 4.0
    • 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 definisce 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  • notifiche 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 fino 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
    • Profili
    • 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
    • Arduino
    • 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
    • La scheda
    • Varianti arduino.cc
    • Open hardware •Arduino è open hardware •Chiunque può creare il proprio clone non ufficiale •Tutti i cloni rimangono compatibili con la piattaforma
    • Cloni
    • 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 + Wifi: Internet of Things Due, Tre! CPU ARM, form factor compatibile Cloni Prezzo, funzionalità built-in aggiuntive
    • Porte e espansioni
    • Shield WIFI MOTOR TFT GPS, Midi, Relé etc ETHERNET GSM
    • Arduino IDE open-source
    • Protocolli Seriale Bluetooth 4.0 I2C USB Client e Host Bluetooth 2.0 SPI Ethernet GPS TWI Wifi RF CAN Zigbee Midi
    • Sensori
    • Esempi • Accelerazione • Temperatura • Pressione atmosferica • Luce • Colore • Infarossi • Magnetismo • GAS • Suono • Resistenza • Flessione • Contatto • Energia • ….
    • Esempio Lampeggiare un led in base all’intervallo definito 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
    • Framework Core Bluetooth
    • 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 • Notifica Characteristic
    • Info.plist e Linking
    • 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: Notifica Modifiche 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 ! options:(NSDictionary *)options Altrimenti
 ALERT
 BLE Non attivo!! - (void)centralManager:(CBCentralManager*)c ! didDiscoverPeripheral:(CBPeripheral*)p 
 advertisementData:(NSDictionary*)a
 RSSI:(NSNumber *)RSSI
    • CBCentralManager - (void)connectPeripheral:! (CBPeripheral *)peripheral ! options:(NSDictionary *)options 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 CBCentralManagerDelegate - (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 CBCentralManagerDelegate - (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]; } - (void)centralManager:(CBCentralManager *)central didFailToConnectPeripheral:(CBPeripheral *)peripheral                  error:(NSError *)error { // connessione fallita } - (void)centralManager:(CBCentralManager *)central 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 Notifiche caratteristica -(void) notification:(CBUUID *)serviceUUID characteristicUUID:(CBUUID *)characteristicUUID p:(CBPeripheral *)p on:(BOOL)on { CBService *service = [self findServiceFromUUID:serviceUUID p:p]; if (!service) { // non trovato return; } CBCharacteristic *characteristic = [self findCharacteristicFromUUID:characteristicUUID service:service]; if (!characteristic) { // non trovata return; } [p setNotifyValue:ON forCharacteristic:characteristic]; }
    • Conferma modifica flag & 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 { CBService *service = [self findServiceFromUUID:serviceUUID p:p]; if (!service) { // non trovato } CBCharacteristic *characteristic = [self findCharacteristicFromUUID:characteristicUUID service:service]; if (!characteristic) { // 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 notifiche! !•! YMSCBCharacteristic da specializzare in sottoclasse! ! gestione stato notifiche, scrittura, lettura, descriptor! ! interpretazione dei dati! !•! YMSCBDescriptor! !! lettura e scrittura valori
    • iBeacon e CoreLocation
    • 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 Notification 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 Notifica • App id applicazione • Titolo notifica • Messaggio • Attributi App • Nome app
    • Arduino e BLE
    • 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 firmware • 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 firmata.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 notifica 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 Identifier, 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
    • Applicazioni pratiche
    • 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
    • Smartwatch Arduino • Parsing comandi iOS • Gestione comandi: • on / off sensore iOS • On / Off Sensore • Abilita Notifiche Valore Sensore • abilita / disabilita invio pacchetti • Parsing Pacchetto dati • visualizza bitmap • Visualizza Dati Sensore • Invio messaggi sul display • Invio notifiche sul display dati • visualizza messaggio testo • reset • Lettura Dati dal Sensore • Scrittura Pacchetto Dati • Gestione del display Sensore
    • Controllo remoto • 2 Motori indipendenti • Accelerometro • Magnetometro • Sensori ad infrarossi • Ultrasuoni
    • Controllo Remoto Arduino • Parsing comandi iOS • Gestione comandi: • on / off sensore • abilita / disabilita invio pacchetti dati • Lettura Dati dal Sensore • Scrittura Pacchetto Dati • Gestione dei motori iOS • On / Off Sensore • Abilita Notifiche Valore Sensore • Parsing Pacchetto dati Sensore • Visualizza Dati Sensore • Invio velocita’ e angolo di sterzata
    • Making Things Talk - Tom Igoe
    • Controller per App 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 • 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 diffusa • Il costo degli adattatori è ancora elevato
    • Prospettive future
    • Wearable Computing Soft circuits Internet of Things UAV Ubiquitous Computing
    • Riepilogo • Col tempo si diffonderanno 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 @fibasile fibasile.github.io