1 /*
2 * Copyright (C) 2014 BlueKitchen GmbH
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the copyright holders nor the names of
14 * contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * 4. Any redistribution, use, or modification is done solely for
17 * personal benefit and not for any commercial purpose or for
18 * monetary gain.
19 *
20 * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BLUEKITCHEN
24 * GMBH OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
27 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
30 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
33 * Please inquire about commercial licensing options at
34 * [email protected]
35 *
36 */
37
38 #define BTSTACK_FILE__ "spp_and_gatt_counter.c"
39
40 // *****************************************************************************
41 /* EXAMPLE_START(spp_and_le_counter): Dual Mode - SPP and LE Counter
42 *
43 * @text The SPP and LE Counter example combines the Bluetooth Classic SPP Counter
44 * and the Bluetooth LE Counter into a single application.
45 *
46 * @text In this Section, we only point out the differences to the individual examples
47 * and how the stack is configured.
48 *
49 * @text Note: To test, please run the example, and then:
50 * - for SPP pair from a remote device, and open the Virtual Serial Port,
51 * - for LE use some GATT Explorer, e.g. LightBlue, BLExplr, to enable notifications.
52 */
53 // *****************************************************************************
54
55 #include <stdint.h>
56 #include <stdio.h>
57 #include <stdlib.h>
58 #include <string.h>
59 #include <inttypes.h>
60
61 #include "btstack.h"
62 #include "spp_and_gatt_counter.h"
63
64 #define RFCOMM_SERVER_CHANNEL 1
65 #define HEARTBEAT_PERIOD_MS 1000
66
67 static uint16_t rfcomm_channel_id;
68 static uint8_t spp_service_buffer[150];
69 static int le_notification_enabled;
70 static hci_con_handle_t att_con_handle;
71
72 // THE Couner
73 static btstack_timer_source_t heartbeat;
74 static int counter = 0;
75 static char counter_string[30];
76 static int counter_string_len;
77
78 static btstack_packet_callback_registration_t hci_event_callback_registration;
79
80 #ifdef ENABLE_GATT_OVER_CLASSIC
81 static uint8_t gatt_service_buffer[70];
82 #endif
83
84 /*
85 * @section Advertisements
86 *
87 * @text The Flags attribute in the Advertisement Data indicates if a device is dual-mode or le-only.
88 */
89 /* LISTING_START(advertisements): Advertisement data: Flag 0x02 indicates dual-mode device */
90 const uint8_t adv_data[] = {
91 // Flags general discoverable
92 0x02, BLUETOOTH_DATA_TYPE_FLAGS, 0x02,
93 // Name
94 0x0b, BLUETOOTH_DATA_TYPE_COMPLETE_LOCAL_NAME, 'L', 'E', ' ', 'C', 'o', 'u', 'n', 't', 'e', 'r',
95 // Incomplete List of 16-bit Service Class UUIDs -- FF10 - only valid for testing!
96 0x03, BLUETOOTH_DATA_TYPE_INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS, 0x10, 0xff,
97 };
98 /* LISTING_END */
99 uint8_t adv_data_len = sizeof(adv_data);
100
101
102 /*
103 * @section Packet Handler
104 *
105 * @text The packet handler of the combined example is just the combination of the individual packet handlers.
106 */
107
packet_handler(uint8_t packet_type,uint16_t channel,uint8_t * packet,uint16_t size)108 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
109 UNUSED(channel);
110
111 bd_addr_t event_addr;
112 uint8_t rfcomm_channel_nr;
113 uint16_t mtu;
114 int i;
115
116 switch (packet_type) {
117 case HCI_EVENT_PACKET:
118 switch (hci_event_packet_get_type(packet)) {
119 case HCI_EVENT_PIN_CODE_REQUEST:
120 // inform about pin code request
121 printf("Pin code request - using '0000'\n");
122 hci_event_pin_code_request_get_bd_addr(packet, event_addr);
123 gap_pin_code_response(event_addr, "0000");
124 break;
125
126 case HCI_EVENT_USER_CONFIRMATION_REQUEST:
127 // inform about user confirmation request
128 printf("SSP User Confirmation Request with numeric value '%06"PRIu32"'\n", little_endian_read_32(packet, 8));
129 printf("SSP User Confirmation Auto accept\n");
130 break;
131
132 case HCI_EVENT_DISCONNECTION_COMPLETE:
133 le_notification_enabled = 0;
134 break;
135
136 case ATT_EVENT_CAN_SEND_NOW:
137 att_server_notify(att_con_handle, ATT_CHARACTERISTIC_0000FF11_0000_1000_8000_00805F9B34FB_01_VALUE_HANDLE, (uint8_t*) counter_string, counter_string_len);
138 break;
139
140 case RFCOMM_EVENT_INCOMING_CONNECTION:
141 // data: event (8), len(8), address(48), channel (8), rfcomm_cid (16)
142 rfcomm_event_incoming_connection_get_bd_addr(packet, event_addr);
143 rfcomm_channel_nr = rfcomm_event_incoming_connection_get_server_channel(packet);
144 rfcomm_channel_id = rfcomm_event_incoming_connection_get_rfcomm_cid(packet);
145 printf("RFCOMM channel %u requested for %s\n", rfcomm_channel_nr, bd_addr_to_str(event_addr));
146 rfcomm_accept_connection(rfcomm_channel_id);
147 break;
148
149 case RFCOMM_EVENT_CHANNEL_OPENED:
150 // data: event(8), len(8), status (8), address (48), server channel(8), rfcomm_cid(16), max frame size(16)
151 if (rfcomm_event_channel_opened_get_status(packet)) {
152 printf("RFCOMM channel open failed, status 0x%02x\n", rfcomm_event_channel_opened_get_status(packet));
153 } else {
154 rfcomm_channel_id = rfcomm_event_channel_opened_get_rfcomm_cid(packet);
155 mtu = rfcomm_event_channel_opened_get_max_frame_size(packet);
156 printf("RFCOMM channel open succeeded. New RFCOMM Channel ID %u, max frame size %u\n", rfcomm_channel_id, mtu);
157 }
158 break;
159
160 case RFCOMM_EVENT_CAN_SEND_NOW:
161 rfcomm_send(rfcomm_channel_id, (uint8_t*) counter_string, counter_string_len);
162 break;
163
164 case RFCOMM_EVENT_CHANNEL_CLOSED:
165 printf("RFCOMM channel closed\n");
166 rfcomm_channel_id = 0;
167 break;
168
169 default:
170 break;
171 }
172 break;
173
174 case RFCOMM_DATA_PACKET:
175 printf("RCV: '");
176 for (i=0;i<size;i++){
177 putchar(packet[i]);
178 }
179 printf("'\n");
180 break;
181
182 default:
183 break;
184 }
185 }
186
187 // ATT Client Read Callback for Dynamic Data
188 // - if buffer == NULL, don't copy data, just return size of value
189 // - if buffer != NULL, copy data and return number bytes copied
190 // @param offset defines start of attribute value
att_read_callback(hci_con_handle_t con_handle,uint16_t att_handle,uint16_t offset,uint8_t * buffer,uint16_t buffer_size)191 static uint16_t att_read_callback(hci_con_handle_t con_handle, uint16_t att_handle, uint16_t offset, uint8_t * buffer, uint16_t buffer_size){
192 UNUSED(con_handle);
193
194 if (att_handle == ATT_CHARACTERISTIC_0000FF11_0000_1000_8000_00805F9B34FB_01_VALUE_HANDLE){
195 return att_read_callback_handle_blob((const uint8_t *)counter_string, counter_string_len, offset, buffer, buffer_size);
196 }
197 return 0;
198 }
199
200 // write requests
att_write_callback(hci_con_handle_t con_handle,uint16_t att_handle,uint16_t transaction_mode,uint16_t offset,uint8_t * buffer,uint16_t buffer_size)201 static int att_write_callback(hci_con_handle_t con_handle, uint16_t att_handle, uint16_t transaction_mode, uint16_t offset, uint8_t *buffer, uint16_t buffer_size){
202 // ignore cancel sent for new connections
203 if (transaction_mode == ATT_TRANSACTION_MODE_CANCEL) return 0;
204 // find characteristic for handle
205 switch (att_handle){
206 case ATT_CHARACTERISTIC_0000FF11_0000_1000_8000_00805F9B34FB_01_CLIENT_CONFIGURATION_HANDLE:
207 le_notification_enabled = little_endian_read_16(buffer, 0) == GATT_CLIENT_CHARACTERISTICS_CONFIGURATION_NOTIFICATION;
208 att_con_handle = con_handle;
209 return 0;
210 case ATT_CHARACTERISTIC_0000FF11_0000_1000_8000_00805F9B34FB_01_VALUE_HANDLE:
211 printf("Write on test characteristic: ");
212 printf_hexdump(buffer, buffer_size);
213 return 0;
214 default:
215 printf("WRITE Callback, handle %04x, mode %u, offset %u, data: ", con_handle, transaction_mode, offset);
216 printf_hexdump(buffer, buffer_size);
217 return 0;
218 }
219 }
220
beat(void)221 static void beat(void){
222 counter++;
223 counter_string_len = snprintf(counter_string, sizeof(counter_string), "BTstack counter %04u", counter);
224 puts(counter_string);
225 }
226
227 /*
228 * @section Heartbeat Handler
229 *
230 * @text Similar to the packet handler, the heartbeat handler is the combination of the individual ones.
231 * After updating the counter, it requests an ATT_EVENT_CAN_SEND_NOW and/or RFCOMM_EVENT_CAN_SEND_NOW
232 */
233
234 /* LISTING_START(heartbeat): Combined Heartbeat handler */
heartbeat_handler(struct btstack_timer_source * ts)235 static void heartbeat_handler(struct btstack_timer_source *ts){
236
237 if (rfcomm_channel_id || le_notification_enabled) {
238 beat();
239 }
240
241 if (rfcomm_channel_id){
242 rfcomm_request_can_send_now_event(rfcomm_channel_id);
243 }
244
245 if (le_notification_enabled) {
246 att_server_request_can_send_now_event(att_con_handle);
247 }
248
249 btstack_run_loop_set_timer(ts, HEARTBEAT_PERIOD_MS);
250 btstack_run_loop_add_timer(ts);
251 }
252 /* LISTING_END */
253
254 /*
255 * @section Main Application Setup
256 *
257 * @text As with the packet and the heartbeat handlers, the combined app setup contains the code from the individual example setups.
258 */
259
260 /* LISTING_START(MainConfiguration): Init L2CAP RFCOMM SDO SM ATT Server and start heartbeat timer */
261 int btstack_main(void);
btstack_main(void)262 int btstack_main(void)
263 {
264 l2cap_init();
265
266 rfcomm_init();
267 rfcomm_register_service(packet_handler, RFCOMM_SERVER_CHANNEL, 0xffff);
268
269 // init SDP, create record for SPP and register with SDP
270 sdp_init();
271 memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
272 spp_create_sdp_record(spp_service_buffer, sdp_create_service_record_handle(), RFCOMM_SERVER_CHANNEL, "SPP Counter");
273 btstack_assert(de_get_len( spp_service_buffer) <= sizeof(spp_service_buffer));
274 sdp_register_service(spp_service_buffer);
275
276 #ifdef ENABLE_GATT_OVER_CLASSIC
277 // init SDP, create record for GATT and register with SDP
278 memset(gatt_service_buffer, 0, sizeof(gatt_service_buffer));
279 gatt_create_sdp_record(gatt_service_buffer, 0x10001, ATT_SERVICE_GATT_SERVICE_START_HANDLE, ATT_SERVICE_GATT_SERVICE_END_HANDLE);
280 sdp_register_service(gatt_service_buffer);
281 printf("SDP service record size: %u\n", de_get_len(gatt_service_buffer));
282 #endif
283
284 gap_set_local_name("SPP and LE Counter 00:00:00:00:00:00");
285 gap_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
286 gap_discoverable_control(1);
287
288 // setup SM: Display only
289 sm_init();
290
291 // setup ATT server
292 att_server_init(profile_data, att_read_callback, att_write_callback);
293
294 // register for HCI events
295 hci_event_callback_registration.callback = &packet_handler;
296 hci_add_event_handler(&hci_event_callback_registration);
297
298 // register for ATT events
299 att_server_register_packet_handler(packet_handler);
300
301 // setup advertisements
302 uint16_t adv_int_min = 0x0030;
303 uint16_t adv_int_max = 0x0030;
304 uint8_t adv_type = 0;
305 bd_addr_t null_addr;
306 memset(null_addr, 0, 6);
307 gap_advertisements_set_params(adv_int_min, adv_int_max, adv_type, 0, null_addr, 0x07, 0x00);
308 gap_advertisements_set_data(adv_data_len, (uint8_t*) adv_data);
309 gap_advertisements_enable(1);
310
311 // set one-shot timer
312 heartbeat.process = &heartbeat_handler;
313 btstack_run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
314 btstack_run_loop_add_timer(&heartbeat);
315
316 // beat once
317 beat();
318
319 // turn on!
320 hci_power_control(HCI_POWER_ON);
321
322 return 0;
323 }
324 /* LISTING_END */
325 /* EXAMPLE_END */
326