In Bluetooth classic (BR/EDR) systems, a Serial Port Profile (SPP) is an adopted profile defined by the Bluetooth Special Interest Group (SIG) used to emulate a serial port connection over a Bluetooth wireless connection. For BLE systems, an adopted SPP profile over BLE is not defined, thus emulation of a serial port must be implemented as a vendor-specific custom profile.
This reference design consists of two Demos, the BLE SPP server and BLE SPP client that run on their respective endpoints. These devices connect and exchange data wirelessly with each other. This capability creates a virtual serial link over the air. Each byte input can be sent and received by both the server and client. The SPP server is implemented as the [spp_server](../spp_server) demo while the SPP client is implemented as the [spp_client](../spp_client) demo. Espressif designed the BLE SPP applications to use the UART transport layer but you could adapt this design to work with other serial protocols, such as SPI.
This vendor-specific custom profile is implemented in [main.c](../spp_client/main/main.c) and [main.c](../spp_server/main/main.c).
## Using Examples
### Initialization
Both the server and client will first initialize the UART and BLE. The server demo will set up the serial port service with standard GATT and GAP services in the attribute server. The client demo will scan the BLE broadcast over the air to find the SPP server.
### Event Processing
The SPP server has two main event processing functions for BLE event:
```c
static int ble_spp_server_gap_event(struct ble_gap_event *event, void *arg);
static int ble_svc_gatt_handler(uint16_t conn_handle, uint16_t attr_handle,struct ble_gatt_access_ctxt *ctxt, void *arg);
```
The SPP client has one main event processing functions for BLE event:
These are some queues and tasks used by SPP application:
Queues:
* spp_uart_queue - Uart data messages received from the Uart
Tasks:
*`ble_server_uart_task` - process Uart
### Packet Structure
After the Uart received data, the data will be posted to Uart task. Then, in the UART_DATA event, the raw data may be retrieved. The max length is 120 bytes every time.
If you run the BLE SPP demo with two ESP32 chips, the MTU size will be exchanged for 200 bytes after the ble connection is established, so every packet can be send directly.
If you only run the ble_spp_server demo, and it was connected by a phone, the MTU size may be less than 123 bytes. In such a case the data will be split into fragments and send in turn.
In every packet, we add 4 bytes to indicate that this is a fragment packet. The first two bytes contain "##" if this is a fragment packet, the third byte is the total number of the packets, the fourth byte is the current number of this packet.
The phone APP need to check the structure of the packet if it want to communicate with the ble_spp_server demo.
### Sending Data Wirelessly
The client will be sending WriteNoRsp packets to the server. The server side sends data through notifications. When the Uart receives data, the Uart task places it in the buffer.
### Receiving Data Wirelessly
The server will receive this data in the BLE_GATT_ACCESS_OP_WRITE_CHR event.
### GATT Server Attribute Table
charactertistic|UUID|Permissions
:-:|:-:|:-:
SPP_DATA_RECV_CHAR|0xABF1|READ&WRITE_NR
SPP_DATA_NOTIFY_CHAR|0xABF2|READ&NOTIFY
SPP_COMMAND_CHAR|0xABF3|READ&WRITE_NR
SPP_STATUS_CHAR|0xABF4|READ & NOTIFY
This example creates GATT client and performs passive scan, it then connects to peripheral device if the device advertises connectability and the write characteristic.
It performs three GATT operations against the specified peer:
* Discover all services,characteristics and descriptors.
* After the discovery is completed, take UART input from user and write characteristic.
