SDK BeaconPlus

# BeaconPlus iOS Software Development Kit Guide

**Updating…**

This SDK only support devices based on miniBeaconPlus firmware, non è compatibile con i dispositivi precedenti, come iBeacon, Eddystone e così via. BeaconSET+ SDK supporta più funzionalità rispetto a BeaconSET SDK. Abbiamo riscontrato alcuni problemi nel processo di sviluppo, COSÌ, ti preghiamo di leggere attentamente questo documento per aiutarti a iniziare il prima possibile. Allo stesso tempo, questo documento informerà anche le note e le questioni.

si prega di leggere la parte di questo documento di cui si ha bisogno, parte 1 spiegheremo l'architettura di questo SDK, parte 2 aiuterà gli sviluppatori a iniziare, parte 3 spiegherà le note nei tuoi progressi di sviluppo, parte 4 è possibile ottenere codici e descrizioni di errore.

## Design instructions

We divide the communications between SDK and devices into two stages: Fase di scansione, Fase di connessione. Per facilità di comprensione, diamo un'occhiata alle classi correlate e alle relazioni tra loro.

**MTCentralManager:** direttore globale, controllare lo stato Bluetooth del sistema, lo stato di ascolto cambia, la cosa più importante è scansionare e connettersi ai dispositivi;

**MTPeriferica:** istanza di dispositivi, MTCentralManager creerà un'istanza MTPeripheral mentre trova un dispositivo fisico, un dispositivo corrisponde a un'istanza. ogni istanza MTPeripheral ha una proprietà MTFrameHandler e una proprietà MTConnectionHandler(Queste due proprietà sono spiegate di seguito);

**MTFrameHandler:** Analisi del frame pubblicitario, può analizzare tutti i frame dai dati pubblicitari di un dispositivo. in altre parole, è il fulcro della fase di scansione;

**MTConnectionHandler:** Operatore di connessione. questa classe controlla tutto il funzionamento del dispositivo in fase di connessione.

**MTSensorHandler:** Operatore del sensore, questa classe controlla tutto il funzionamento del sensore del dispositivo in fase di connessione.

\*\*MinewFrame:\*\*cornice di dati, ogni mionewframe(o sottoclasse) l'istanza corrisponde a un frame di dati, solitamente creato da "MTFrameHandler", se un dispositivo pubblicizza più frame di dati(come iBeacon, UID, URL) "MTFrameHandler" creerà più istanze MinewFrame corrispondenti.

**MTOTA Manager:** OTA, utilizzare questa classe solo per aggiornare il firmware del dispositivo.

## Struttura complessiva

![FaroSET+](/risorse/sdksimg/BeaconSET+.3b64ceba.png)

#### Advertisement Stage

in this stage, **MTCentralManager** scansionerà e analizzerà i dati pubblicitari dei dispositivi miniBeaconPlus, **MTCentralManager** creerà **"MTPeriferica"** esempio per ogni dispositivo fisico, gli sviluppatori possono ottenere tutti i dati pubblicitari tramite la sua proprietà **MTFrameHandler**.

#### Connection Stage

After a **MTPeripheral** connected, lo sviluppatore può apportare alcune modifiche al dispositivo tramite **MTConnectionHandler**(una proprietà dell'istanza **MTPeripheral**).

#### OTA Operations

In general, OTA operations is complicated, so we encapsulates the **MTOTAManager** to perform firmware update operations, please note developer can update devices only in connection status.

## Get Started

### Prepare

#### Development environment:

-   **Xcode9+**， due to the DFU and Zip Framework based on Swift4.0, so please use Xcode9 or high version to develop;
-   **iOS8**, we limit the minimum iOS system version to 8.0;

### Import to Project

#### Manualmente

1.  copy the framework files to your project folder，include **"MTBeaconPlus.framework"**, **"iOSDFULibrary.framework"**, **"Zip.framework"**, then add them to your project, make sure the **"target"** is checked. as the screenshot below: ![add frameworks](/resources/sdksimg/add_frameworks.8a932d1c.png)
    
2.  find: **"Target"** -> **General** -> **Embedded Binaries**, click the **"+"** sotto, add that 3 framework files. allo stesso tempo, make sure add them to **"Linked Frameworks and Librarys"**, mentre lo screenshot esplodeva:
    
    ![assicurarsi che i quadri](/resources/sdksimg/make_sure_frameworks.d4466176.png)
    
3.  \*sull'uso di Swift, lo sviluppatore dovrebbe aggiungere a **"Obiettivo C BridgingHeader.h"** file al progetto(per favore fallo da solo), Poi aggiungi **"importare < MTBeaconPlus/MTBeaconPlus.h >"** al fascicolo.
    
4.  \*utilizzando Objective-C, find: “Target” -> Building Settings -> Always Embed Swift Standard Libraries" ,quindi imposta sì
    
5.  !!!su iOS 10 e al di sopra, Apple aggiunge il controllo dell'autorità del Bluetooth, devi aggiungere la stringa a "info.plist" file del tuo progetto: _Privacy - Descrizione utilizzo periferica Bluetooth_ - _"la tua descrizione"_. as the screenshot below.
    
    ![bp_access](/risorse/sdksimg/bp_access.795e088e.png)
    
    6.  !!! In iOS13 e versioni successive, Apple ha aggiunto restrizioni sulle autorizzazioni sull'API Bluetooth. È necessario aggiungere una stringa al file info.plist del progetto: Privacy-Descrizione dell'utilizzo di Bluetooth Always-"La tua descrizione dell'utilizzo".

### Inizia a sviluppare

##### Get sharedInstance of Manager

First of all, lo sviluppatore dovrebbe ottenere l'istanza condivisa di Manager:

```c
// get sharedInstance
MTCentralManager *manager = [MTCentralManager sharedInstance];

// ascolta il cambiamento del bluetooth dell'iPhone
// *** anche ottenere da "stato" proprietà.
// *** questo SDK funzionerà normalmente solo mentre state == PowerStatePoweredOn!
manager.stateBlock = ^(Stato PowerState) {
     NSLog("stato attuale del Bluetooth：%D",stato);
};
```

##### Scan devices

start scanning task to find devices around you, quindi puoi ottenere il loro contenuto pubblicitario, connettersi al dispositivo e modificare i parametri.

```c
/*
  manager: Istanza condivisa di MTCentralManager
*/

// avviare l'attività di scansione
[gestore startScan:^(NSArray<MTPeriferica *> *peris){
  
   // Attraversa la matrice，ottenere l'istanza di ogni dispositivo.
   // ** puoi anche visualizzarli nelle visualizzazioni.
    per(NSInteger i = 0; io < peris.count; io ++){
        MTPeriferica *peri = peris[io];
        
        // ottenere FrameHandler di un dispositivo.
        // **some properties maybe nil
        MTFrameHandler *framer = peri.framer; 
        NSString *nome = framer.nome;          // nome del dispositivo, may nil
        NSInteger rssi = framer.rssi;          // rssi
        NSInteger battery = framer.battery;    // batteria,may nil
        NSString *mac = framer.mac;            // indirizzo MAC,may nil
        NSArray *frames = framer.advFrames;    // tutti i frame di dati del dispositivo (come:iBeacon，UID，URL...）
    }
}];

```

at the sometime, è possibile interrompere l'attività di scansione in questo modo:

```c
/*
  manager: Istanza condivisa di MTCentralManager
*/

// interrompere il compito.
[gestore stopScan];
```

now the developer can get all advertisement data of device in this way. Prossimo, parleremo di come ottenere i dati del frame, come **iBeacon**, **URL**, **UID** e così via..

Fare riferimento all'esempio di codice riportato di seguito.

```c
/*
  aFrameHandler: un'istanza MTFrameHandler.
*/

NSArray *frames = aFrameHandler.advFrames;
per (NSInteger i = 0; io < conteggio.frame; io ++){
    MinewFrame *frame = fotogrammi[io];
    
    interruttore(frame.frameType){
      caso FrameiBeacon:
        {
          MinewiBeacon *bea = (MinewiBeacon *)telaio;
          NSLog(@"iBeacon:%@, %ld, %ld, %@",bea.uuid, bea.major, bea.minor, bea.lastUpdate);
        }
           rottura;
        
      caso FrameUID:
        {
           MinewUID *uid = (Il mio nuovoUID *)telaio;
           NSLog(@"UID:%@, %@, %ld, %@", uid.namespaceId, uid.istanzaId, uid.txPower, uid.lastUpdate);
        }
           rottura;
        
        caso FrameDeviceInfo:
        {
            MinewDeviceInfo *info = (MinewDeviceInfo *)telaio;
            NSLog(@"Informazioni sul dispositivo: %ld, %@, %@, %@", (lungo)info.batteria, info.mac, info.nome, info.lastUpdate);
        }
            rottura;
        
        caso FrameTLM:
        {
            MinewTLM *tlm = (MinewTLM *)telaio;
            NSLog(@"TLM: %ld, %F, %ld, %ld, %@", tlm.batteriaVol, tlm.temperatura, tlm.advCount, (lungo)tlm.secCount, tlm.lastUpdate);
        }
            rottura;
        
        caso FrameURL:
        {
            MinewURL *url = (MinewURL *)telaio;
            NSLog(@"URL: %ld, %@, %@", url.txPower, url.urlString, url.ultimoaggiornamento);
        }
            rottura;
        
        caso FrameLineBeacon:
        {
            MinewLineBeacon *lineBeacon = (MinewLineBeacon *)telaio;
            // Se necessario, VendorKey e lotKey possono essere ottenute dopo la connessione tramite altre operazioni. Per dettagli, fare riferimento alla sezione "Ottenere i dati di ciascun canale".
            NSLog(@"LineBeacon:%@, %@, %@, %ld, %@", lineBeacon.hwId, lineBeacon.authenticationCode, lineBeacon.timestamp, lineBeacon.txPower, lineBeacon.lastUpdate);
        }
            rottura;
                    
      /*
         Se necessario, puoi gestire altri tipi di dati. 
      */
    }
}

```

**Important:** per tutti i tipi di valore del sensore, se è uguale a _MTNAValue_（un valore non disponibile da noi definito, nel fascicolo "MTPublicHeader.h"), significa che questo valore non è disponibile.

Fare riferimento all'esempio di codice riportato di seguito:

```c
/*
    aHT: a MinewHTSensor instance
    aLight: a MinewLightSensor instance
    aAcc：un'istanza MinewAccSensor
*/

Se (aHT.temperatura == Valore MTNA) {
    NSLog(@"questo valore non è disponibile.")
}

Se (aLight.luxValue == MTNAValue) {
    NSLog(@"questo valore non è disponibile.")
}

Se (aAcc.XAsse == Valore MTNA) {
    NSLog(@"questo valore non è disponibile.")
}
```

##### Connect to device

Connect to the device in order to do more operations(modificare parametro, OTA). scoprirai che quando ti connetti al dispositivo potrebbe essere necessaria la password, così il "Blocco convalida password" non deve essere NULL, altrimenti l'app si bloccherà!!!!**

Fare riferimento all'esempio di codice riportato di seguito.

```c
/*
  manager： a MTCentralManager sharedInstance
  aMTPeripheral： un'istanza MTPeripheral
*/

// listen the change of device connection state
aMTPeripheral.connector.statusChangeHandler = ^(Stato ConnectionStatus, NSErrore *errore) {
    
    /*
     typedefNS_ENUM(NSInteger, Stato connessione) {
         StatusConnectFailed = -2,
         StatoDisconnesso = -1,
         StatoUndifined = 0,
         StatoConnessione,
         StatoConnesso,
         StatoLetturaInfo,
         StatusDeviceValidating,
         StatoPasswordConvalida,
         StatoSycingTime,
         StatoLetturaCollegabile,
         Funzionalità di lettura dello stato,
         StatusReadingFrames,
         Trigger di lettura dello stato,
         StatoLetturaSensoreInfo,
         StatoCompletato,
     };
     */
     
    /*
     sono presenti più stati quando ci si connette al dispositivo,
     soltanto "stato == StatoCompletato" significa il successo delle operazioni di connessione.
     se appare un'eccezione, l'errore non sarà NULL
    */
    
};

// Connettersi al dispositivo
// aMTPeripheral è un'istanza del dispositivo
// !!!:Avvertimento: passwordRequire non deve essere NULL!!!
[gestore connectToPeripheral:aMTPassword perifericaRichiedi:^(MTPasswordBlock blocco password){
     // la lunghezza della stringa della password deve essere 8.
    // !!! leggere il contenuto di input da UITextField come password in fase di sviluppo.
    NSString *password = @"minew123";
    passwordBlock(parola d'ordine);
}];

// disconnettersi dal dispositivo.
[gestore disconnessioneFromPeriperal:aMTPeriferica];
```

##### Get base information

the developer can get device information and modify parameters when a device connected.

l'esempio di codice seguente consente allo sviluppatore di ottenere i dati di base del dispositivo.

```c
/*
   aMTPeriferica：un'istanza MTPeripheral
*/

MTConnectionHandler *con = aMTPeripheral.connector;

ConnectionStatus conSte = con.status;  // current connection status
NSDictionary *infoDict = con.infoDict; // Informazioni sul dispositivo, ad esempio：(Versione del firmware： 0.9.1）;
NSString *mac = con.macString; // indirizzo MAC；
Collegabile capace = con.connettibile; // dispositivo collegabile，Nessuno sconosciuto，Nessuna disabilitazione，Yes enable
Version version = con.version; // Versione del firmware；
PasswordStatus pwdStatus = con.passwordStatus; // la password richiede o meno. Nessuno, Require

MTConnectionFeature *feature = con.feature; // device features
NSInteger slotAtitude = feature.slotAtitude; // attitudine dello slot(S), 
FeatureSupported feaSup = feature.featureSupported; // i parametri possono essere modificati：nessuno，avv,txpower,adv/txpower
NSArray<Numero NS *> *supFrames = feature.supportedSlots; // frames supported（multiple）
NSArray<Numero NS *> *supTxpower = feature.supportedTxpowers; // Txpower supported（multiple）
```

**PS:** **Proprietà _Version_ di MTConnectionHandler**.

```c
The version value comes form firmware version， controllare il valore della versione per scoprire le funzioni supportate dal dispositivo:
 
// init value
VersionUndefined

// versione base, solo funzione di base.
VersioneBase

// questa versione o successiva supporta la password di connessione personalizzata e il riquadro delle informazioni sul dispositivo.
Versione0_9_8

// questa versione o successiva supporta lo spegnimento remoto.
Versione0_9_9

// questa versione o versioni successive attivano il supporto.
Versione2_0_0

// questa versione o successiva supporta i trigger con le configurazioni adv.
Versione2_2_60

// valore ideale, supportare tutte le funzionalità.
VersioneMax = 1000
```

##### Get data of each Slot

Next, parliamo dei dati dei parametri di ogni slot, il motivo per cui ne parliamo è perché tutto il contenuto della modifica dei parametri è qui.

**Fessura** :Prima di leggere il codice, parliamo di slot, puoi pensare alle slot come a uno strumento pubblicitario, pubblicizza anche il contenuto dei dati pubblicitari "non lo so" qual è il contenuto. come il 6 alle slot potrebbe piacere questo:

| Numero di slot | 0 | 1 | 2 | 3 | 4 | 5 |
| --- | --- | --- | --- | --- | --- | --- |
| Contenuti pubblicitari | iBeacon | TLM | UID | URL | Sensore HTS | Nessuno |
| Intervallo Adv（ms） | 1000 | 2000 | 500 | 900 | 3000 | 0 |
| RSSI@0/1m（dbm） | \-1 | 0 | \-4 | \-10 | \-3 | 0 |
| Txpower（dbm） | 4 | 0 | \-4 | 4 | 0 | 0 |

Per significato della tabella, il no.0** lo slot pubblicizzerà i dati **iBeacon**, lo slot **N.1** pubblicizzerà i dati **TLM**, …, lo slot **No.5** non pubblicizzerà alcun dato. ognuno di essi ha il proprio **intervallo pubblicitario**, **Txpower** e **Calibrazione RSSI**. Sono indipendenti l'uno dall'altro.

PS: **RSSI di calibrazione(RSSI@0/1m)** è l'RSSI quando il dispositivo @ 0/1m(iBeacon lo è 1, altri 0).

Come ottenere i dati sugli annunci pubblicitari degli slot? fare riferimento all'esempio di codice riportato di seguito.

```c
/*
    con: un'istanza MTConnectionHandler
*/

// ogni slot ha un frame del dispositivo corrente.
// l'atteggiamento di questo array è uguale all'atteggiamento dello slot(feature.slotAtitude)
// 
// In stretta conformità con l'ordine dello slot，ad esempio：0. -> MinewiBeacon，1. -> Il mio nuovoUID ...
NSArray<MinewFrame *> *frames = con.allFrames;

/*
   Supponiamo che lo slot n. 3 contenga dati iBeacon, lo slot n. 4 ha i dati UID.
   proviamo ad analizzare i dati dello slot n.3.
*/

// a causa del punto predefinito è MinewFrame(la superclasse di MinewiBeacon), quindi dobbiamo fare una conversione.

// get the frame of No.3 slot
MinewFrame *frame = frames[2];

// controlla che questo slot contenga dati iBeacon o meno,
// *Non puoi verificare se ne confermi il tipo.
per (NSInteger i = 0; io < conteggio.frame; io ++){
MinewFrame *frame = fotogrammi[io];

interruttore (frame.frameType) {
caso FrameiBeacon:
{
    MinewiBeacon *iBeacon = (MinewiBeacon *)telaio;

// iBeacon
    NSString *uuid = iBeacon.uuid;   // uuid
    NSInteger major = iBeacon.major;  // major
    NSInteger minor = iBeacon.minor;  // minore

// The parameters of the slot
    NSInteger slotNumber = iBeacon.slotNumber;           // number of the slot
    NSInteger slotAdvInterval = iBeacon.slotAdvInterval; // advertisement interval
    NSInteger slotAdvTxpower = iBeacon.slotAdvTxpower;   // iBeacon：RSSI@1 milione di altri： RSSI@0m
    NSInteger slotRadioTxpower = iBeacon.slotRadioTxpower; // radio Txpower  
}
    rottura;
    
caso FrameURL:
{
    // URL
    MinewURL *url = (MinewURL *)telaio;
    NSString *urlStr = url.urlString;
    
    // I parametri dello slot si ottengono allo stesso modo
}
    rottura;
    
caso FrameUID:
{
    // UID
    MinewUID *uid = (Il mio nuovoUID *)telaio;
    NSString *namespaceId = uid.namespaceId;
    NSString *instanceId = uid.instanceId;
    
    // I parametri dello slot si ottengono allo stesso modo
}
    rottura;

caso FrameLineBeacon:
{
    // LineBeacon(Il metodo di acquisizione è speciale)
    MTLineBeaconData *lineBeaconData = self.currentPeripheral.connector.slotHandler.slotFrameDataDic[FrameTypeString(FrameLineBeacon)];
    NSString *hwid = lineBeaconData.hwId;
    NSString *vendorKey = lineBeaconData.vendorKey;
    NSString *lotKey = lineBeaconData.lotKey;
    
    // I parametri dello slot si ottengono allo stesso modo
}
    rottura;
/*
   Se necessario, puoi gestire altri tipi di dati. 
*/
predefinito:
    rottura;
}
```

You can analyze the data of other slots in the same way, vale la pena notare che quando **frameType == FrameNone** significa che lo slot non ha dati: Da un'altra prospettiva significa che questo slot è chiuso.

##### Change slot data

The developer can modify advertisement and parameters of every slot freely via our APi.

Dividiamo il frame di dati in **frame statici** e **frame dinamici**:

-   **Telaio statico**: i dati dell'annuncio non cambieranno quando è stato pubblicizzato, come **iBeacon**, **ID**, **URL**
-   **Telaio dinamico**: i dati dell'annuncio cambieranno durante la pubblicità, come **TLM**, **Sensor**

Please refer to the code example below:

```c
/*
   aConnectionHandler:un'istanza MTConnectionHandler
*/

// create a uid instance
MinewUID *uid = [[Allocazione MinewUID]dentro];

// impostato "ID spazio dei nomi" E "ID istanza" of UID
uid.namespaceId = @"0123456789abdcdcba12";
uid.IDistanza = @"0123456789DC";

// the other parameters of slot
uid.slot = 1;  // The number of slot which you want to modify
uid.slotAdvInterval = 600;  // advertisement interval
uid.slotAdvTxpower = -3;    // RSSI@0m
uid.slotRadioTxpower = 4;   // Potenza radiofonica.

// scrivere sul dispositivo.
// dettaglio: 1.lascia che lo slot n. 1 pubblicizzi i dati UID, ID spazio dei nomi：0123456789ID istanza abdcdcba12：0123456789DC
//         2.impostare l'intervallo pubblicitario dello slot n. 1 su 600 ms, RSSI@0m a -3dbm, potenza di trasmissione radio a 4 dBm 
[aConnectionHandler writeFrame:completamento del fluido:^(BOOL riuscito, NSErrore *errore){
     Se (successo) {
        NSLog(@"scrivere correttamente il frame sul dispositivo.");   
     } 
     altrimenti se(errore) {
        NSLog(@"Errore:%@", errore)
     }
}];
```

Becareful, il parametro slot ha intervalli:

-   **Intervallo pubblicitario**: 100 - 5000 (SM)
-   **RSSI@0m**: -127 - 0 (dbm)

**Il più importante**: Radio txpower non è una portata, è un grado, ad esempio: -8, -4, 0, 4. puoi ottenere tutti i Radio Txpower supportati dalla proprietà della funzionalità di "MTConnectionHandler"

```c
/*
   caratteristica: una proprietà di MTConnectionHandler.
*/

// ottieni tutta la potenza radio supportata del dispositivo corrente.
NSArray<Numero NS *> *supTx = feature.supportedTxpowers
```

OK, puoi modificare qualsiasi slot nel modo sopra, se vuoi chiudere uno slot, è sufficiente creare un'istanza **MinewFrame** e impostare la sua proprietà **frameType** su **FrameNone**, quindi scrivi questo frame sul dispositivo. oh, non dimenticare di impostare un numero di slot per lo slot che desideri chiudere.

##### Set lineBeacon

The LineBeacon frame needs to call writeFrame method, e quindi vengono chiamati i due metodi seguenti per impostare l'hwid del lineBeacon, fornitoreKey, e lotKey.

```c
// lotKey:Lunghezza di 16, whid:Lunghezza di 10,vendorKey:Lunghezza di 8，includere a-f/A-F/0-9.

// imposta la lotKey di LineBeacon
[self.currentPeripheral.connector.slotHandler lineBeaconSetLotkey:@"0011223344556677" completamento:^(BOOL riuscito) {
    Se (successo) {
        NSLog(@"Set LineBeacon's lotKey success");
    } altro {
        NSLog(@"Set LineBeacon's lotKey failed");
    }
}];

// set LineBeacon's hwid LineBeacon's vendorKey
[self.currentPeripheral.connector.slotHandler lineBeaconSetHWID:@"0011223344" VendorKey:@"00112233" completamento:^(BOOL riuscito) {
    Se (successo) {
        NSLog(@"Set LineBeacon's hwid and vendorKey success");
    } altro {
        NSLog(@"Set LineBeacon's hwid and vendorKey failed");
    }
}];

```

##### Change global parameter

Global parameter of device is a device level feature, such as connectable, password require, reset to default and etc.

Fare riferimento all'esempio di codice riportato di seguito.

```c
/*
   aConnectionHandler: un'istanza MTConnectionHandler
*/
// reset the device
[aConnectionHandler resetFactorySettings:^(BOOL riuscito, NSErrore *errore){
    Se(successo){
        NSLog(@"Operation success!");
    }
    altro {
        NSLog(@"Opertion failed!");
    }
}];

// update connectable settings
// ConnectableYES: app can connect to the device, ConnectableNO app can't connect to the device.
// if you set connectableNO, you can connect to device by press the button on device maybe next time.
// DANGER!!!:if there is no button on device and set ConnectableNO, the app can't connect to device even forever.
[aConnectionHandler updateConnectable:ConnectableYES completion:^(BOOL riuscito, NSErrore *errore){
    Se(successo){
        NSLog(@"Operation success!");
    }
    altro {
        NSLog(@"Opertion failed!");
    }
}];

// Modify/Add password
// !!!: the password string length must be 8, digits or letters；
// it will add password if device has no password, update password if device has a password
[aConnectinoHandler modifyPassword:@"12345678" completamento:^(BOOL riuscito, NSErrore *errore){
    Se(successo){
        NSLog(@"Operation success!");
    }
    altro {
        NSLog(@"Opertion failed!");
    }
}];

// remove password
[aConnectionHandler removePassword:^(BOOL riuscito, NSErrore *errore){
    Se(successo){
        NSLog(@"Operation success!");
    }
    altro {
        NSLog(@"Opertion failed!");
    }
}];

// remote shut down the device.
// DANGER!!!: please make sure there a button on device, otherwise it may not boot again.if the Model Number String is Beacon Plus-BL,not work.
[aConnectionHandler poweroff^(BOOL riuscito, NSErrore *errore){
    Se(successo){
        NSLog(@"Operation success!");
    }
    altro {
        NSLog(@"Opertion failed!");
    }
}];
```

##### Sensor data

BeaconPlus devices integrated a variety of sensors: **HT(Temperature and Humidity )**, **Light**, **Acceleration** and etc, currently we provide APi for read HT/Sixaxis/Magnetometer/AtmosphericPressure History data and set PIR param data.

Please make sure the device has **HT Sensor**, otherwise you can't get data correctly.

Fare riferimento all'esempio di codice riportato di seguito.

```c
/*
   aConnectionHandler: un'istanza MTConnectionHandler
*/

// read HT History from the device
[aConnectionHandler.sensorHandler readSensorHistory:^(MTSensorData *dati){
  
   // a record corresponds to an instance
   NSInteger time = ((MTSensorHTData *)dati).timestamp;   // il timestamp Unix；
   doppia temperatura = ((MTSensorHTData *)dati).temperatura;    // dati sulla temperatura；
   doppio humi = ((MTSensorHTData *)dati).umidità;       // dati di umidità；
   Indice NSInteger = ((MTSensorHTData *)dati).indice;      // numero di questi dati；
  
   Se (((MTSensorHTData *)dati).endStatus == EndStatusNone){
       NSLog(@"non ci sono dati.");
   }
   altrimenti se (((MTSensorHTData *)dati).endStatus == EndStatusSuccess) {
       NSLog(@"sincronizzazione dei dati del sensore riuscita!");
   }
   altrimenti se (((MTSensorHTData *)dati).endStatus == EndStatusError) {
       NSLog(@"qualcosa non va nella sincronizzazione dei progressi.");   
   }
}];
```

you can vividly display these data with the curve, tavolo o altro.

Assicurati che il dispositivo disponga di **Sensore PIR**, otherwise you can't get data correctly.

Fare riferimento all'esempio di codice riportato di seguito.

```c
/*
   aConnectionHandler: a MTConnectionHandler instance
   aRepeat: un bool,whether to allow repeated triggers
   aTime:tempo di attivazione, il sensore a infrarossi può essere nuovamente attivato dopo il tempo di attivazione
*/

// impostare i parametri PIR sul dispositivo
[aConnectionHandler.sensorHandler pirSet:aRipetizione e Ritardo:completamento aTime:^(MTSensorData *dati){
   
    Se (stato.dati) {
        NSLog(@"successo");
    }
    altro {
        NSLog(@"fallito");
    }
}];
```

##### Set triggers

BeaconPlus device has triggers, puoi impostare trigger per ogni slot, il dispositivo pubblicizzerà lo slot corrispondente solo quando la condizione di attivazione è soddisfatta.

Fare riferimento all'esempio di codice riportato di seguito.

```c
/*
   aConnectionHandler: un'istanza MTConnectionHandler
*/

NSInteger sn = 2;                          // Slot di destinazione：2
Tipo TriggerType = TriggerTypeTempAbove;   // Condizione scatenante：temperature above
NSInteger value = 10;                      // valore：10

// creare un'istanza di trigger
// questo trigger significa quando la temperatura > 10 soddisfare la condizione.
MTTriggerData *trigger = [[Allocazione MTTriggerData]initWithSlot:sntriggerType:tipo valore:valore];

// scrivere sul dispositivo.
[aConnectionHandler writeTrigger:completamento dell'attivazione:^(BOOL riuscito, NSErrore){
    Se(successo){
        NSLog(@"scrivere il trigger con successo!");
    }
    altro {
        NSLog(@"trigger di scrittura non riuscito!");
    }
}];

NSInteger slotAtitude = 2;                 // Slot di destinazione：2
Tipo TriggerType = TriggerTypeTempAbove;   // Condizione scatenante：temperature above
NSInteger value = 10;                      // temperatura superiore：10

// Continue broadcasting after triggering if necessary
trigger.always = true;        // Whether to continue broadcasting after triggering
trigger.advInterval = 100;    // The broadcast interval
trigger.radioTxpower = -20;   // La potenza del segnale trasmesso

// scrivere sul dispositivo.
[self.connectedPeripheral.connector writeTrigger:completamento dell'attivazione:^(BOOL riuscito) {
    Se(successo){
        NSLog(@"scrivere il trigger con successo!");
    }
    altro {
        NSLog(@"trigger di scrittura non riuscito!");
    }
}];

```

Set and query whether the vibration is turned on, il frame trasmesso dal sensore di vibrazione verrà ricevuto quando la vibrazione è attivata, e il frame di trasmissione del sensore di vibrazione non verrà trasmesso quando la vibrazione è disattivata.

```c
   
 //    MTVibrationTypeOpen,
//    MTVibrationTypeChiudi,
//    Errore MTVibrationType,
  [self.currentPeripheral.connector.sensorHandler setVibrationStatus:MTVibrationTypeOpen CompletionHandler:^(BOOL ha successo) {

}];

[self.currentPeripheral.connector.sensorHandler queryVibrationStatu:^(BOOL ha successo, Tipo MTVibrationType) {

}];
```

Set and query the sensitivity of the vibration sensor.

```c
    //    Tipo di sensibilità MTSuper alta,
    //    Tipo di sensibilità MTAlta,
    //    Tipo di sensibilità MTMiddle,
    //    Tipo di sensibilità MT Bassa,
    //    Tipo di sensibilità MTSSuperbassa,
    [self.currentPeripheral.connector.sensorHandler setSensitivity:MTSensitivityTypeHigh CompletionHandler:^(BOOL ha successo) {
        
    }];

[self.currentPeripheral.connector.sensorHandler querySensitivity:^(BOOL ha successo, Tipo MTSensitivityType) {
        
    }];
```

Set and query the vibration sensor warning time interval. L'ora di inizio deve essere inferiore all'ora di fine, preciso all'ora e ai minuti. Inoltre, i parametri devono essere calcolati. Per esempio, da 6:10 la mattina a 10:00 in serata, ora di inizio = 6 \* 3600 + 10 \* 60 = 22200, fineOra = 22 \* 3600 + 0 \* 60 = 79200.

```c
    // fuso orario = ore*3600 + minuti*60
    // 22200 = 6*3600 + 10*60 = 6:30
    [self.currentPeripheral.connector.sensorHandler setFirstAlarmTimeIntervalWithAlarmStatus:MTVibrationTypeOpen StartTime:22200 Tempo scaduto:79200 CompletionHandler:^(BOOL ha successo) {
        
    }];
    
    [self.currentPeripheral.connector.sensorHandler queryFirstAlarmTimeInterval:^(BOOL ha successo, Tipo MTVibrationType, uint32_t startTime, uint32_t endTime) {
        NSLog(@"vibrazioneTipo:%@, Ora di inizio:%dora %dminuto, Tempo scaduto:%dora %dminuto", tipo == MTVibrationTypeOpen ? @"Aprire" : @"Chiudi o Errore", orainizio/3600, startTime600/60, fine/3600, fineOra600/60);
    }];
    
    [self.currentPeripheral.connector.sensorHandler setSecondAlarmTimeIntervalWithAlarmStatus:MTVibrationTypeOpen StartTime:22200 Tempo scaduto:79200 CompletionHandler:^(BOOL ha successo) {
        
    }];
    
    [self.currentPeripheral.connector.sensorHandler querySecondAlarmTimeInterval:^(BOOL ha successo, Tipo MTVibrationType, uint32_t startTime, uint32_t endTime) {
        
    }];
    
    [self.currentPeripheral.connector.sensorHandler setThirdAlarmTimeIntervalWithAlarmStatus:MTVibrationTypeOpen StartTime:22200 Tempo scaduto:79200 CompletionHandler:^(BOOL ha successo) {
        
    }];
    
    [self.currentPeripheral.connector.sensorHandler queryThirdAlarmTimeInterval:^(BOOL ha successo, Tipo MTVibrationType, uint32_t startTime, uint32_t endTime) {
        
    }];
```

### Set broadcast rate

When the model is MBM01 and the firmware version is 2.5.x, è possibile impostare il Bluetooth 4.0 1Velocità di trasmissione Mbps o Bluetooth 5.0 125Velocità di trasmissione Kbps per il canale frame.

Ciascuno dei sei canali di trasmissione occupa un valore. Quando il valore è impostato su 0, rappresenta il Bluetooth 4.2 1Modalità di trasmissione Mbps, e quando il valore è impostato su 1, rappresenta il Bluetooth 5.0 125Modalità di trasmissione Kbps.

\*\*Va notato che attualmente iOS non può ottenere il pacchetto radio con una frequenza radio di 125 Kbps, e Android non ha questo problema. Questo è, il canale frame del Bluetooth 5.0 la velocità di trasmissione è impostata su 125 Kbps su iOS. Una volta completata l'impostazione, la cornice non può essere scansionata su iPhone, ma la cornice può essere scansionata su Android. \*\*

```c
    [self.currentPeripheral.connector.sensorHandler queryBroadcastSpeed:^(BOOL ha successo, NSArray * _Trasmissione non nullaSpeedOfSlotArray) {
        NSLog(@"La velocità di trasmissione del primo canale è %@", [broadcastSpeedOfSlotArray[0] intValore] == 1 ? @"Bluetooth5.0 125Kbps" : @"Bluetooth4.0 1Mbps");
    }];
    
    // Quando si imposta la velocità di trasmissione, l'array in entrata ha sei valori, e ciascun valore corrisponde a sei canali. 0 significa che la velocità di trasmissione del Bluetooth 4.0 è 1Mbps, E 1 significa che la velocità di trasmissione del Bluetooth 5.0 è 125Kbps. Per esempio, se il primo e il secondo canale sono impostati sulla trasmissione a 125 Kbps, e gli altri canali sono impostati sulla trasmissione a 1Mbps, quindi le impostazioni sono le seguenti:
    [self.currentPeripheral.connector.sensorHandler setBroadcastSpeed:@[@1,@1,@0,@0,@0,@0] CompletionHandler:^(BOOL ha successo) {
        
    }];
```

### Set the parameter configuration items of the configurable firmware of the Acc sensor

This function belongs to the exclusive supporting function of customized firmware, consultare il personale aziendale interessato prima di utilizzarlo.

Il sensore ACC può essere configurato con firmware e voci di configurazione dei parametri che possono essere impostati.

ODR ( Tasso di uscita ) :

| descrizione | valore |
| --- | --- |
| 1Hz | 0 |
| 10Hz | 1 |
| 25Hz | 2 |
| 50Hz | 3 |
| 100Hz | 4 |
| 200Hz | 5 |
| 400Hz | 6 |
| 1600Hz（bassa potenza） | 7 |
| 1344HZ (FC/normale) /5000HZ(bassa potenza) | 8 |

wakeup\_threshold ( mg ) : 0 ~ 2000

wakeup\_duration ( SM ) : 0 ~ 127000

```c  [self.currentPeripheral.connector.sensorHandler queryAccSensorParameterWithCompletionHandler:^(BOOL ha successo, NSInteger ord, NSInteger wakeupThreshold, NSInteger wakeupDuration) {  
      
    }];

[self.currentPeripheral.connector.sensorHandler setAccSensorParameterWithOdr:0 Soglia di risveglio:200 Durata della sveglia:1000 CompletionHandler:^(BOOL ha successo) {   
      
    }];
```

At the end of this part, puoi fare riferimento a tutto il codice sopra per svilupparlo. Ovviamente abbiamo preso nota per ogni API nell'SDK, se c'è qualcosa di nuovo, aggiorneremo questo documento.

## Appunti

1.  In progresso di sviluppo, potresti scoprire che ci sono **più istanze MTPeripheral** che corrispondono a un dispositivo fisico. Su questo punto, abbiamo consultato gli ingegneri di Apple. ci hanno detto che attualmente sulla piattaforma iOS, Framework CoreBluetooth ostile ai dispositivi con slot multipli(in particolare i dati pubblicitari stanno cambiando). per questo motivo a volte l'app non riesce a connettersi al dispositivo, Google Eddystone risolve questo problema **premendo il pulsante sui dispositivi Eddystone**, anche il nostro dispositivo supporta questa operazione.
    
    iOS11 non presenta questo problema.
    
2.  In fase di scansione, alcune proprietà potrebbero essere pari a zero, in particolare l'indirizzo MAC(restrizione di iOS),se il dispositivo corrente pubblicizza il frame **DeviceInfo**, quindi puoi ottenere il nome, Indirizzo MAC e batteria.
    
3.  Dopo 5 meno l'app connessa al dispositivo, il dispositivo prenderà l'iniziativa di disconnettersi.
    
4.  Se la visualizzazione in esecuzione non riesce a trovare il percorso dopo aver aggiunto l'SDK, remove the package and add it again at General-> Frameworks,Biblioteche,e contenuto incorporato

## Other

BeaconPlus SDK is also used in our BeaconSET+ app. Se hai bisogno di una comprensione più intuitiva della nostra attrezzatura beaconPlus e delle funzioni corrispondenti dell'SDK, puoi anche scaricare l'app BeaconSET+ per saperne di più. (Promemoria: L'app BeaconSET+ e l'SDK BeaconPlus devono essere utilizzati con apparecchiature prodotte dalla nostra azienda)

## Modifica registro

-   2017.10.11 v1.0 prima versione;
-   2019.01.07 v1.1 seconda versione;
-   2019.07.11 v1.2 cambia lo spegnimento;
-   2020.03.27 v1.10.0 aggiungi LineBeacon;
-   2020.07.27 v1.10.1 Ottimizza il recupero e l'impostazione del frame LineBeacon
-   2020.10.27 v1.10.2 Aggiunta la proprietà lastUpdate per ogni frame trasmesso
-   2021.4.21 v1.11.0 Aggiunto sensore Sixaxis/Magnetometro/Pressione atmosferica
-   2021.4.28 v1.11.1 Aggiunto sensore di vibrazione
-   2021.09.16 v1.13.0 Aggiunto sensore pir
-   2021.10.9 v1.14.0 Bluetooth appena impostato 5.0 velocità di trasmissione
-   2021.12.27 v1.14.1 Aggiunti nuovi elementi di configurazione dei parametri per il firmware configurabile del sensore di accelerazione adattabile
-   2022.5.10 Supporta la modifica dei parametri del frame ACC
-   2022.6.1 v1.16.0 Aggiunto frame di trasmissione IN100 MinewMBeaconInfo
-   2023.11.13 v1.17.0 Risolto il problema con l'arresto anomalo di WriteFrame; supporta la scansione in background