Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Perpustakaan Bluetooth Rendah Energi
**penting**
Pustaka ini di-host di repositori Amazon-Freertos yang tidak digunakan lagi. Kami menyarankan Anda [mulai di sini](freertos-getting-started-modular.md) ketika Anda membuat proyek baru. Jika Anda sudah memiliki proyek FreeRTOS yang sudah ada berdasarkan repositori Amazon-Freertos yang sekarang tidak digunakan lagi, lihat. [Panduan Migrasi Repositori Github Amazon-freertos](github-repo-migration.md)
## Ikhtisar
FreeRTOS mendukung penerbitan dan berlangganan topik Message Queuing Telemetry Transport (MQTT) melalui Bluetooth Low Energy melalui perangkat proxy, seperti ponsel. Dengan pustaka [FreeRTOS Bluetooth Low](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html) Energy (BLE), mikrokontroler Anda dapat berkomunikasi dengan aman dengan broker MQTT. AWS IoT
![\[Perangkat BLE terhubung ke AWS IoT Core via MQTT/HTTP/Websocket melalui AWS Cognito.\]](http://docs.aws.amazon.com/id_id/freertos/latest/userguide/images/blediagram.jpg)
Menggunakan Ponsel SDKs untuk Perangkat Bluetooth FreeRTOS, Anda dapat menulis aplikasi seluler asli yang berkomunikasi dengan aplikasi yang disematkan pada mikrokontroler Anda melalui BLE. Untuk informasi selengkapnya tentang ponsel SDKs, lihat[Ponsel SDKs untuk perangkat Bluetooth FreeRTOS](freertos-ble-mobile.md).
Pustaka FreeRTOS BLE mencakup layanan untuk mengkonfigurasi jaringan Wi-Fi, mentransfer sejumlah besar data, dan menyediakan abstraksi jaringan melalui BLE. Pustaka FreeRTOS BLE juga menyertakan middleware dan APIs level yang lebih rendah untuk kontrol lebih langsung atas tumpukan BLE Anda.
## Arsitektur
Tiga lapisan membentuk perpustakaan FreerTOS BLE: layanan, middleware, dan pembungkus tingkat rendah.
![\[Lapisan arsitektur cloud: Aplikasi Pengguna, Layanan, Middleware, Pembungkus Tingkat Rendah, Produsen BLE Stack.\]](http://docs.aws.amazon.com/id_id/freertos/latest/userguide/images/ble-architecture.png)
### Layanan
Lapisan layanan FreeRTOS BLE terdiri dari empat layanan Generic Attribute (GATT) yang memanfaatkan middleware: APIs
+ Informasi perangkat
+ Penyediaan Wi-Fi
+ Abstraksi jaringan
+ Transfer objek besar
#### Informasi perangkat
Layanan informasi Perangkat mengumpulkan detail tentang mikrokontroler Anda, termasuk:
+ Versi FreeRTOS yang digunakan perangkat Anda.
+ AWS IoT Titik akhir akun tempat perangkat terdaftar.
+ Unit Transmisi Maksimum Energi Rendah Bluetooth (MTU).
#### Penyediaan Wi-Fi
Layanan penyediaan Wi-Fi memungkinkan mikrokontroler dengan kemampuan Wi-Fi untuk melakukan hal berikut:
+ Daftar jaringan dalam jangkauan.
+ Simpan jaringan dan kredenal jaringan ke memori flash.
+ Tetapkan prioritas jaringan.
+ Hapus jaringan dan kredenal jaringan dari memori flash.
#### Abstraksi jaringan
Layanan abstraksi jaringan mengabstraksi jenis koneksi jaringan untuk aplikasi. API umum berinteraksi dengan tumpukan perangkat keras Wi-Fi, Ethernet, dan Bluetooth Low Energy perangkat Anda, memungkinkan aplikasi kompatibel dengan beberapa jenis koneksi.
#### Transfer Objek Besar
Layanan Transfer Objek Besar mengirimkan data ke, dan menerima data dari, klien. Layanan lain, seperti penyediaan Wi-Fi dan abstraksi jaringan, menggunakan layanan Transfer Objek Besar untuk mengirim dan menerima data. Anda juga dapat menggunakan Large Object Transfer API untuk berinteraksi langsung dengan layanan.
#### MQTT di atas BLE
MQTT over BLE berisi profil GATT untuk membuat layanan proxy MQTT melalui BLE. Layanan proxy MQTT memungkinkan klien MQTT untuk berkomunikasi dengan broker AWS MQTT melalui perangkat gateway. Misalnya, Anda dapat menggunakan layanan proxy untuk menghubungkan perangkat yang menjalankan FreeRTOS AWS ke MQTT melalui aplikasi ponsel cerdas. Perangkat BLE adalah server GATT dan mengekspos layanan dan karakteristik untuk perangkat gateway. Server GATT menggunakan layanan dan karakteristik yang terbuka ini untuk melakukan operasi MQTT dengan cloud untuk perangkat itu. Untuk detail selengkapnya, lihat [Lampiran A: MQTT di atas profil BLE GATT](#freertos-ble-gatt-profile).
### Middleware
FreeRTOS Bluetooth Low Energy middleware adalah abstraksi dari level yang lebih rendah. APIs Middleware APIs membuat antarmuka yang lebih ramah pengguna ke tumpukan Bluetooth Low Energy.
Menggunakan middleware APIs, Anda dapat mendaftarkan beberapa callback, di beberapa lapisan, ke satu acara. Menginisialisasi middleware Bluetooth Low Energy juga menginisialisasi layanan dan mulai beriklan.
#### Langganan callback fleksibel
Misalkan perangkat keras Bluetooth Low Energy Anda terputus, dan layanan MQTT melalui Bluetooth Low Energy perlu mendeteksi pemutusan sambungan. Aplikasi yang Anda tulis mungkin juga perlu mendeteksi peristiwa pemutusan yang sama. Middleware Bluetooth Low Energy dapat merutekan acara ke berbagai bagian kode tempat Anda telah mendaftarkan callback, tanpa membuat lapisan yang lebih tinggi bersaing untuk sumber daya tingkat yang lebih rendah.
### Pembungkus tingkat rendah
Pembungkus FreeRTOS Bluetooth Low Energy tingkat rendah adalah abstraksi dari tumpukan Bluetooth Low Energy pabrikan. Pembungkus tingkat rendah menawarkan satu set umum APIs untuk kontrol langsung atas perangkat keras. Tingkat rendah APIs mengoptimalkan penggunaan RAM, tetapi terbatas dalam fungsionalitas.
Gunakan layanan Bluetooth Low Energy APIs untuk berinteraksi dengan layanan Bluetooth Low Energy. Layanan APIs menuntut lebih banyak sumber daya daripada tingkat rendah APIs.
## Ketergantungan dan persyaratan
Pustaka Bluetooth Low Energy memiliki dependensi langsung berikut:
+ Perpustakaan [Kontainer Linear](https://docs.aws.amazon.com/freertos/latest/lib-ref/c-sdk/linear_containers/index.html)
+ Lapisan platform yang berinteraksi dengan sistem operasi untuk manajemen thread, timer, fungsi jam, dan akses jaringan.
![\[Diagram arsitektur yang menunjukkan komponen: BLE, Daftar/Antrian, Jaringan, dan Jam, dengan panah arah yang menunjukkan interaksi.\]](http://docs.aws.amazon.com/id_id/freertos/latest/userguide/images/ble-dependencies.png)
Hanya layanan Penyediaan Wi-Fi yang memiliki dependensi pustaka FreeRTOS:
****
| Layanan GATT | Dependensi |
| --- | --- |
| Penyediaan Wi-Fi | [Perpustakaan Wi-Fi](freertos-wifi.md) |
Untuk berkomunikasi dengan broker AWS IoT MQTT, Anda harus memiliki AWS akun dan Anda harus mendaftarkan perangkat Anda sebagai barang. AWS IoT Untuk informasi selengkapnya tentang pengaturan, lihat [Panduan AWS IoT Pengembang](https://docs.aws.amazon.com/iot/latest/developerguide/).
FreeRTOS Bluetooth Low Energy menggunakan Amazon Cognito untuk otentikasi pengguna di perangkat seluler Anda. Untuk menggunakan layanan proxy MQTT, Anda harus membuat identitas Amazon Cognito dan kumpulan pengguna. Setiap Identitas Amazon Cognito harus memiliki kebijakan yang sesuai yang dilampirkan padanya. Untuk informasi selengkapnya, lihat [Panduan Developer Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/) .
## File konfigurasi perpustakaan
Aplikasi yang menggunakan FreeRTOS MQTT melalui layanan Bluetooth Low Energy harus menyediakan file header, di `iot_ble_config.h` mana parameter konfigurasi ditentukan. Parameter konfigurasi yang tidak ditentukan mengambil nilai default yang ditentukan dalam`iot_ble_config_defaults.h`.
Beberapa parameter konfigurasi penting meliputi:
**`IOT_BLE_ADD_CUSTOM_SERVICES`**
Memungkinkan pengguna untuk membuat layanan mereka sendiri.
**`IOT_BLE_SET_CUSTOM_ADVERTISEMENT_MSG`**
Memungkinkan pengguna untuk menyesuaikan iklan dan memindai pesan respons.
Untuk informasi selengkapnya, lihat [Referensi API Energi Rendah Bluetooth](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html).
## Pengoptimalan
Saat mengoptimalkan kinerja papan Anda, pertimbangkan hal berikut:
+ Tingkat rendah APIs menggunakan lebih sedikit RAM, tetapi menawarkan fungsionalitas terbatas.
+ Anda dapat mengatur `bleconfigMAX_NETWORK` parameter dalam file `iot_ble_config.h` header ke nilai yang lebih rendah untuk mengurangi jumlah tumpukan yang dikonsumsi.
+ Anda dapat meningkatkan ukuran MTU ke nilai maksimumnya untuk membatasi buffering pesan, dan membuat kode berjalan lebih cepat dan mengkonsumsi lebih sedikit RAM.
## Pembatasan penggunaan
Secara default, pustaka FreeRTOS Bluetooth Low Energy menyetel `eBTpropertySecureConnectionOnly` properti ke TRUE, yang menempatkan perangkat dalam mode Secure Connections Only. Seperti yang ditentukan oleh [Spesifikasi Inti Bluetooth](https://www.bluetooth.com/specifications/bluetooth-core-specification) v5.0, Vol 3, Bagian C, 10.2.4, ketika perangkat berada dalam mode Secure Connections Only, mode keamanan LE tertinggi 1 level, level 4, diperlukan untuk akses ke atribut apa pun yang memiliki izin lebih tinggi dari level 1 mode keamanan LE terendah, level 1. Pada mode keamanan LE 1 level 4, perangkat harus memiliki kemampuan input dan output untuk perbandingan numerik.
Berikut adalah mode yang didukung, dan properti terkaitnya:
**Mode 1, Level 1 (Tanpa keamanan)**
```
/* Disable numeric comparison */
#define IOT_BLE_ENABLE_NUMERIC_COMPARISON ( 0 )
#define IOT_BLE_ENABLE_SECURE_CONNECTION ( 0 )
#define IOT_BLE_INPUT_OUTPUT ( eBTIONone )
#define IOT_BLE_ENCRYPTION_REQUIRED ( 0 )
```
**Mode 1, Level 2 (Pasangan yang tidak diautentikasi dengan enkripsi)**
```
#define IOT_BLE_ENABLE_NUMERIC_COMPARISON ( 0 )
#define IOT_BLE_ENABLE_SECURE_CONNECTION ( 0 )
#define IOT_BLE_INPUT_OUTPUT ( eBTIONone )
```
**Mode 1, Level 3 (Pasangan yang diautentikasi dengan enkripsi)**
Mode ini tidak didukung.
**Mode 1, Level 4 (Diautentikasi LE Secure Connections dipasangkan dengan enkripsi)**
Mode ini didukung secara default.
Untuk informasi tentang mode keamanan LE, lihat [Spesifikasi Inti Bluetooth](https://www.bluetooth.com/specifications/bluetooth-core-specification) v5.0, Vol 3, Bagian C, 10.2.1.
## Inisialisasi
Jika aplikasi Anda berinteraksi dengan tumpukan Bluetooth Low Energy melalui middleware, Anda hanya perlu menginisialisasi middleware. Middleware menangani inisialisasi lapisan bawah tumpukan.
### Middleware
**Untuk menginisialisasi middleware**
1. Inisialisasi driver perangkat keras Bluetooth Low Energy sebelum Anda memanggil API middleware Bluetooth Low Energy.
1. Aktifkan Bluetooth Energi Rendah.
1. Inisialisasi middleware dengan. `IotBLE_Init()`
**catatan**
Langkah inisialisasi ini tidak diperlukan jika Anda menjalankan AWS demo. Inisialisasi demo ditangani oleh Network Manager, yang terletak di. `freertos/demos/network_manager`
### Tingkat rendah APIs
Jika Anda tidak ingin menggunakan layanan FreeRTOS Bluetooth Low Energy GATT, Anda dapat melewati middleware dan berinteraksi langsung dengan level rendah untuk menghemat sumber daya. APIs
**Untuk menginisialisasi tingkat rendah APIs**
1.
****
Inisialisasi driver perangkat keras Bluetooth Low Energy sebelum Anda menelepon. APIs Inisialisasi driver bukan bagian dari Bluetooth Low Energy APIs low-level.
1.
****
Bluetooth Low Energy low-level API menyediakan enable/disable panggilan ke tumpukan Bluetooth Low Energy untuk mengoptimalkan daya dan sumber daya. Sebelum menelepon APIs, Anda harus mengaktifkan Bluetooth Low Energy.
```
const BTInterface_t * pxIface = BTGetBluetoothInterface();
xStatus = pxIface->pxEnable( 0 );
```
1.
****
Manajer Bluetooth berisi APIs yang umum untuk Bluetooth Low Energy dan Bluetooth classic. Callback untuk manajer umum harus diinisialisasi kedua.
```
xStatus = xBTInterface.pxBTInterface->pxBtManagerInit( &xBTManagerCb );
```
1.
****
Adaptor Bluetooth Low Energy cocok di atas API umum. Anda harus menginisialisasi callback-nya seperti Anda menginisialisasi API umum.
```
xBTInterface.pxBTLeAdapterInterface = ( BTBleAdapter_t * ) xBTInterface.pxBTInterface->pxGetLeAdapter();
xStatus = xBTInterface.pxBTLeAdapterInterface->pxBleAdapterInit( &xBTBleAdapterCb );
```
1.
****
Daftarkan aplikasi pengguna baru Anda.
```
xBTInterface.pxBTLeAdapterInterface->pxRegisterBleApp( pxAppUuid );
```
1.
****
Inisialisasi callback ke server GATT.
```
xBTInterface.pxGattServerInterface = ( BTGattServerInterface_t * ) xBTInterface.pxBTLeAdapterInterface->ppvGetGattServerInterface();
xBTInterface.pxGattServerInterface->pxGattServerInit( &xBTGattServerCb );
```
Setelah Anda menginisialisasi adaptor Bluetooth Low Energy, Anda dapat menambahkan server GATT. Anda hanya dapat mendaftarkan satu server GATT dalam satu waktu.
```
xStatus = xBTInterface.pxGattServerInterface->pxRegisterServer( pxAppUuid );
```
1.
****
Atur properti aplikasi seperti koneksi aman saja dan ukuran MTU.
```
xStatus = xBTInterface.pxBTInterface->pxSetDeviceProperty( &pxProperty[ usIndex ] );
```
## Referensi API
Untuk referensi API selengkapnya, lihat Referensi [API Energi Rendah Bluetooth](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html).
## Contoh penggunaan
Contoh di bawah ini menunjukkan cara menggunakan pustaka Bluetooth Low Energy untuk mengiklankan dan membuat layanan baru. Untuk aplikasi demo FreeRTOS Bluetooth Low Energy lengkap, [lihat Aplikasi Demo Energi Rendah Bluetooth](https://docs.aws.amazon.com/freertos/latest/userguide/ble-demo.html).
### Iklan
1. Dalam aplikasi Anda, atur UUID iklan:
```
static const BTUuid_t _advUUID =
{
.uu.uu128 = IOT_BLE_ADVERTISING_UUID,
.ucType = eBTuuidType128
};
```
1. Kemudian tentukan fungsi `IotBle_SetCustomAdvCb` callback:
```
void IotBle_SetCustomAdvCb( IotBleAdvertisementParams_t * pAdvParams, IotBleAdvertisementParams_t * pScanParams)
{
memset(pAdvParams, 0, sizeof(IotBleAdvertisementParams_t));
memset(pScanParams, 0, sizeof(IotBleAdvertisementParams_t));
/* Set advertisement message */
pAdvParams->pUUID1 = &_advUUID;
pAdvParams->nameType = BTGattAdvNameNone;
/* This is the scan response, set it back to true. */
pScanParams->setScanRsp = true;
pScanParams->nameType = BTGattAdvNameComplete;
}
```
Callback ini mengirimkan UUID dalam pesan iklan dan nama lengkap dalam respons pemindaian.
1. Buka`vendors/vendor/boards/board/aws_demos/config_files/iot_ble_config.h`, dan atur `IOT_BLE_SET_CUSTOM_ADVERTISEMENT_MSG` ke`1`. Ini memicu `IotBle_SetCustomAdvCb` panggilan balik.
### Menambahkan layanan baru
Untuk contoh lengkap layanan, lihat`freertos/.../ble/services`.
1. Buat UUIDs untuk karakteristik dan deskriptor layanan:
```
#define xServiceUUID_TYPE \
{\
.uu.uu128 = gattDemoSVC_UUID, \
.ucType = eBTuuidType128 \
}
#define xCharCounterUUID_TYPE \
{\
.uu.uu128 = gattDemoCHAR_COUNTER_UUID,\
.ucType = eBTuuidType128\
}
#define xCharControlUUID_TYPE \
{\
.uu.uu128 = gattDemoCHAR_CONTROL_UUID,\
.ucType = eBTuuidType128\
}
#define xClientCharCfgUUID_TYPE \
{\
.uu.uu16 = gattDemoCLIENT_CHAR_CFG_UUID,\
.ucType = eBTuuidType16\
}
```
1. Buat buffer untuk mendaftarkan pegangan karakteristik dan deskriptor:
```
static uint16_t usHandlesBuffer[egattDemoNbAttributes];
```
1. Buat tabel atribut. Untuk menyimpan beberapa RAM, tentukan tabel sebagai file`const`.
**penting**
Selalu buat atribut secara berurutan, dengan layanan sebagai atribut pertama.
```
static const BTAttribute_t pxAttributeTable[] = {
{
.xServiceUUID = xServiceUUID_TYPE
},
{
.xAttributeType = eBTDbCharacteristic,
.xCharacteristic =
{
.xUuid = xCharCounterUUID_TYPE,
.xPermissions = ( IOT_BLE_CHAR_READ_PERM ),
.xProperties = ( eBTPropRead | eBTPropNotify )
}
},
{
.xAttributeType = eBTDbDescriptor,
.xCharacteristicDescr =
{
.xUuid = xClientCharCfgUUID_TYPE,
.xPermissions = ( IOT_BLE_CHAR_READ_PERM | IOT_BLE_CHAR_WRITE_PERM )
}
},
{
.xAttributeType = eBTDbCharacteristic,
.xCharacteristic =
{
.xUuid = xCharControlUUID_TYPE,
.xPermissions = ( IOT_BLE_CHAR_READ_PERM | IOT_BLE_CHAR_WRITE_PERM ),
.xProperties = ( eBTPropRead | eBTPropWrite )
}
}
};
```
1. Buat array callback. Array callback ini harus mengikuti urutan yang sama seperti array tabel yang didefinisikan di atas.
Misalnya, jika `vReadCounter` dipicu saat `xCharCounterUUID_TYPE` diakses, dan `vWriteCommand` dipicu saat `xCharControlUUID_TYPE` diakses, tentukan array sebagai berikut:
```
static const IotBleAttributeEventCallback_t pxCallBackArray[egattDemoNbAttributes] =
{
NULL,
vReadCounter,
vEnableNotification,
vWriteCommand
};
```
1. Buat layanan:
```
static const BTService_t xGattDemoService =
{
.xNumberOfAttributes = egattDemoNbAttributes,
.ucInstId = 0,
.xType = eBTServiceTypePrimary,
.pusHandlesBuffer = usHandlesBuffer,
.pxBLEAttributes = (BTAttribute_t *)pxAttributeTable
};
```
1. Panggil API `IotBle_CreateService` dengan struktur yang Anda buat pada langkah sebelumnya. Middleware menyinkronkan pembuatan semua layanan, sehingga setiap layanan baru harus sudah ditentukan ketika `IotBle_AddCustomServicesCb` callback dipicu.
1. Setel `IOT_BLE_ADD_CUSTOM_SERVICES` ke `1` dalam`vendors/vendor/boards/board/aws_demos/config_files/iot_ble_config.h`.
1. Buat IotBle \$1 AddCustomServicesCb di aplikasi Anda:
```
void IotBle_AddCustomServicesCb(void)
{
BTStatus_t xStatus;
/* Select the handle buffer. */
xStatus = IotBle_CreateService( (BTService_t *)&xGattDemoService, (IotBleAttributeEventCallback_t *)pxCallBackArray );
}
```
## Porting
### Input pengguna dan output periferal
Koneksi yang aman membutuhkan input dan output untuk perbandingan numerik. `eBLENumericComparisonCallback`Acara dapat didaftarkan menggunakan manajer acara:
```
xEventCb.pxNumericComparisonCb = &prvNumericComparisonCb;
xStatus = BLE_RegisterEventCb( eBLENumericComparisonCallback, xEventCb );
```
Periferal harus menampilkan passkey numerik dan mengambil hasil perbandingan sebagai input.
### Implementasi API porting
Untuk mem-port FreeRTOS ke target baru, Anda harus menerapkan APIs beberapa untuk layanan Penyediaan Wi-Fi dan fungsionalitas Bluetooth Low Energy.
#### Bluetooth Energi Rendah APIs
Untuk menggunakan middleware FreeRTOS Bluetooth Low Energy, Anda harus menerapkan beberapa. APIs
##### APIs umum antara GAP untuk Bluetooth Classic dan GAP untuk Bluetooth Low Energy
+ `pxBtManagerInit`
+ `pxEnable`
+ `pxDisable`
+ `pxGetDeviceProperty`
+ `pxSetDeviceProperty`(Semua opsi wajib diharapkan `eBTpropertyRemoteRssi` dan`eBTpropertyRemoteVersionInfo`)
+ `pxPair`
+ `pxRemoveBond`
+ `pxGetConnectionState`
+ `pxPinReply`
+ `pxSspReply`
+ `pxGetTxpower`
+ `pxGetLeAdapter`
+ `pxDeviceStateChangedCb`
+ `pxAdapterPropertiesCb`
+ `pxSspRequestCb`
+ `pxPairingStateChangedCb`
+ `pxTxPowerCb`
##### APIs khusus untuk GAP untuk Bluetooth Low Energy
+ `pxRegisterBleApp`
+ `pxUnregisterBleApp`
+ `pxBleAdapterInit`
+ `pxStartAdv`
+ `pxStopAdv`
+ `pxSetAdvData`
+ `pxConnParameterUpdateRequest`
+ `pxRegisterBleAdapterCb`
+ `pxAdvStartCb`
+ `pxSetAdvDataCb`
+ `pxConnParameterUpdateRequestCb`
+ `pxCongestionCb`
##### Peladen GATT
+ `pxRegisterServer`
+ `pxUnregisterServer`
+ `pxGattServerInit`
+ `pxAddService`
+ `pxAddIncludedService`
+ `pxAddCharacteristic`
+ `pxSetVal`
+ `pxAddDescriptor`
+ `pxStartService`
+ `pxStopService`
+ `pxDeleteService`
+ `pxSendIndication`
+ `pxSendResponse`
+ `pxMtuChangedCb`
+ `pxCongestionCb`
+ `pxIndicationSentCb`
+ `pxRequestExecWriteCb`
+ `pxRequestWriteCb`
+ `pxRequestReadCb`
+ `pxServiceDeletedCb`
+ `pxServiceStoppedCb`
+ `pxServiceStartedCb`
+ `pxDescriptorAddedCb`
+ `pxSetValCallbackCb`
+ `pxCharacteristicAddedCb`
+ `pxIncludedServiceAddedCb`
+ `pxServiceAddedCb`
+ `pxConnectionCb`
+ `pxUnregisterServerCb`
+ `pxRegisterServerCb`
Untuk informasi selengkapnya tentang porting pustaka FreeRTOS Bluetooth Low Energy ke platform Anda, [lihat Mem-porting Perpustakaan Energi Rendah Bluetooth di Panduan Porting](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-ble.html) FreerTOS.
# Ponsel SDKs untuk perangkat Bluetooth FreeRTOS
**penting**
Pustaka ini di-host di repositori Amazon-Freertos yang tidak digunakan lagi. Kami menyarankan Anda [mulai di sini](freertos-getting-started-modular.md) ketika Anda membuat proyek baru. Jika Anda sudah memiliki proyek FreeRTOS yang sudah ada berdasarkan repositori Amazon-Freertos yang sekarang tidak digunakan lagi, lihat. [Panduan Migrasi Repositori Github Amazon-freertos](github-repo-migration.md)
Anda dapat menggunakan Ponsel SDKs untuk Perangkat Bluetooth FreerTOS untuk membuat aplikasi seluler yang berinteraksi dengan mikrokontroler Anda melalui Bluetooth Low Energy. Ponsel juga SDKs dapat berkomunikasi dengan AWS layanan, menggunakan Amazon Cognito untuk otentikasi pengguna.
## Android SDK untuk perangkat Bluetooth FreeRTOS
Gunakan SDK Android untuk Perangkat Bluetooth FreerTOS untuk membangun aplikasi seluler Android yang berinteraksi dengan mikrokontroler Anda melalui Bluetooth Low Energy. SDK tersedia di [GitHub](https://github.com/aws/amazon-freertos-ble-android-sdk/).
[Untuk menginstal Android SDK untuk perangkat Bluetooth FreeRTOS, ikuti petunjuk untuk “Menyiapkan SDK” di file README.md proyek.](https://github.com/aws/amazon-freertos-ble-android-sdk/blob/master/README.md)
Untuk informasi tentang pengaturan dan menjalankan aplikasi mobile demo yang disertakan dengan SDK, lihat [Prasyarat](ble-demo.md#ble-demo-prereqs) dan[Aplikasi demo SDK Seluler Energi Rendah FreeRTOS Bluetooth](ble-demo.md#ble-sdk-app).
## SDK iOS untuk perangkat Bluetooth FreeRTOS
Gunakan SDK iOS untuk Perangkat Bluetooth FreeRTOS untuk membangun aplikasi seluler iOS yang berinteraksi dengan mikrokontroler Anda melalui Bluetooth Low Energy. SDK tersedia di [GitHub](https://github.com/aws/amazon-freertos-ble-ios-sdk/).
**Untuk menginstal SDK iOS**
1. Instal [CocoaPods](http://cocoapods.org/):
```
$ gem install cocoapods
$ pod setup
```
**catatan**
Anda mungkin perlu menggunakannya `sudo` untuk menginstal CocoaPods.
1. Instal SDK dengan CocoaPods (tambahkan ini ke podfile Anda):
```
$ pod 'FreeRTOS', :git => 'https://github.com/aws/amazon-freertos-ble-ios-sdk.git'
```
Untuk informasi tentang pengaturan dan menjalankan aplikasi mobile demo yang disertakan dengan SDK, lihat [Prasyarat](ble-demo.md#ble-demo-prereqs) dan[Aplikasi demo SDK Seluler Energi Rendah FreeRTOS Bluetooth](ble-demo.md#ble-sdk-app).
## Lampiran A: MQTT di atas profil BLE GATT
### Detail Layanan GATT
MQTT melalui BLE menggunakan instance layanan GATT transfer data untuk mengirim pesan MQTT Concise Binary Object Representation (CBOR) antara perangkat FreeRTOS dan perangkat proxy. Layanan transfer data memperlihatkan karakteristik tertentu yang membantu mengirim dan menerima data mentah melalui protokol BLE GATT. Ini juga menangani fragmentasi dan perakitan muatan yang lebih besar dari ukuran BLE maximum transfer unit (MTU).
**Layanan UUID**
`A9D7-166A-D72E-40A9-A002-4804-4CC3-FF00`
**Instans Layanan**
Salah satu contoh layanan GATT dibuat untuk setiap sesi MQTT dengan broker. Setiap layanan memiliki UUID unik (dua byte) yang mengidentifikasi jenisnya. Setiap instance individu dibedakan oleh ID instance.
Setiap layanan dipakai sebagai layanan utama pada setiap perangkat server BLE. Anda dapat membuat beberapa instance layanan pada perangkat tertentu. Jenis layanan proxy MQTT memiliki UUID yang unik.
**Karakteristik**
Format konten karakteristik: **CBOR**
Ukuran nilai karakteristik maks: 512 byte
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/freertos/latest/userguide/freertos-ble-library.html)
**Persyaratan Prosedur GATT **
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/freertos/latest/userguide/freertos-ble-library.html)
**Jenis Pesan **
Jenis pesan berikut dipertukarkan.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/freertos/latest/userguide/freertos-ble-library.html)
**Karakteristik Transfer Muatan Besar **
**TXLargePesan **
TXLargePesan digunakan oleh perangkat untuk mengirim muatan besar yang lebih besar dari ukuran MTU yang dinegosiasikan untuk koneksi BLE.
+ Perangkat mengirimkan byte MTU pertama dari muatan sebagai pemberitahuan melalui karakteristik.
+ Proxy mengirimkan permintaan baca pada karakteristik ini untuk byte yang tersisa.
+ Perangkat mengirimkan hingga ukuran MTU atau byte yang tersisa dari muatan, mana yang kurang. Setiap kali, itu meningkatkan pembacaan offset dengan ukuran muatan yang dikirim.
+ Proxy akan terus membaca karakteristik hingga mendapat muatan panjang nol atau muatan kurang dari ukuran MTU.
+ Jika perangkat tidak mendapatkan permintaan baca dalam batas waktu yang ditentukan, transfer gagal dan proxy serta gateway melepaskan buffer.
+ Jika proxy tidak mendapatkan respons baca dalam batas waktu tertentu, transfer gagal dan proxy melepaskan buffer.
**RXLargePesan **
RXLargePesan digunakan oleh perangkat untuk menerima muatan besar yang lebih besar dari ukuran MTU yang dinegosiasikan untuk koneksi BLE.
+ Proxy menulis pesan, hingga ukuran MTU, satu per satu, menggunakan tulis dengan respons pada karakteristik ini.
+ Perangkat menyangga pesan hingga menerima permintaan tulis dengan panjang nol atau panjang kurang dari ukuran MTU.
+ Jika perangkat tidak mendapatkan permintaan tulis dalam batas waktu yang ditentukan, transfer gagal dan perangkat melepaskan buffer.
+ Jika proxy tidak mendapatkan respons tulis dalam batas waktu tertentu, transfer gagal dan proxy melepaskan buffer.