27 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75, 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
28 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69, 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
29 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D, 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
30 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51, 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
31 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05, 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
32 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19, 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
33 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D, 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
34 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21, 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
35 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95, 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
36 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89, 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
37 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD, 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
38 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1, 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
39 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5, 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
40 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9, 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
41 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD, 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
42 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1, 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
57 rfcomm_dcid[0] = 0x51;
58 rfcomm_dcid[1] = 0x00;
65 RFCOMMConnected =
false;
67 waitForLastCommand =
false;
79 if (RFCOMMConnected && SDPConnected)
100 if (((l2capinbuf[0] | (l2capinbuf[1] << 8)) == (hci_handle | 0x2000))) {
101 if ((l2capinbuf[6] | (l2capinbuf[7] << 8)) == 0x0001) {
103 #ifdef DEBUG_USB_HOST
104 Notify(PSTR(
"\r\nL2CAP Command Rejected - Reason: "), 0x80);
105 D_PrintHex<uint8_t > (l2capinbuf[13], 0x80);
107 D_PrintHex<uint8_t > (l2capinbuf[12], 0x80);
108 Notify(PSTR(
" Data: "), 0x80);
109 D_PrintHex<uint8_t > (l2capinbuf[17], 0x80);
111 D_PrintHex<uint8_t > (l2capinbuf[16], 0x80);
113 D_PrintHex<uint8_t > (l2capinbuf[15], 0x80);
115 D_PrintHex<uint8_t > (l2capinbuf[14], 0x80);
119 Notify(PSTR(
"\r\nL2CAP Connection Request - PSM: "), 0x80);
120 D_PrintHex<uint8_t > (l2capinbuf[13], 0x80);
122 D_PrintHex<uint8_t > (l2capinbuf[12], 0x80);
123 Notify(PSTR(
" SCID: "), 0x80);
124 D_PrintHex<uint8_t > (l2capinbuf[15], 0x80);
126 D_PrintHex<uint8_t > (l2capinbuf[14], 0x80);
127 Notify(PSTR(
" Identifier: "), 0x80);
128 D_PrintHex<uint8_t > (l2capinbuf[9], 0x80);
130 if ((l2capinbuf[12] | (l2capinbuf[13] << 8)) ==
SDP_PSM) {
131 identifier = l2capinbuf[9];
132 sdp_scid[0] = l2capinbuf[14];
133 sdp_scid[1] = l2capinbuf[15];
135 }
else if ((l2capinbuf[12] | (l2capinbuf[13] << 8)) ==
RFCOMM_PSM) {
136 identifier = l2capinbuf[9];
137 rfcomm_scid[0] = l2capinbuf[14];
138 rfcomm_scid[1] = l2capinbuf[15];
142 if ((l2capinbuf[16] | (l2capinbuf[17] << 8)) == 0x0000) {
143 if (l2capinbuf[12] == sdp_dcid[0] && l2capinbuf[13] == sdp_dcid[1]) {
146 }
else if (l2capinbuf[12] == rfcomm_dcid[0] && l2capinbuf[13] == rfcomm_dcid[1]) {
152 if (l2capinbuf[12] == sdp_dcid[0] && l2capinbuf[13] == sdp_dcid[1]) {
154 identifier = l2capinbuf[9];
156 }
else if (l2capinbuf[12] == rfcomm_dcid[0] && l2capinbuf[13] == rfcomm_dcid[1]) {
158 identifier = l2capinbuf[9];
162 if (l2capinbuf[12] == sdp_dcid[0] && l2capinbuf[13] == sdp_dcid[1]) {
164 identifier = l2capinbuf[9];
166 }
else if (l2capinbuf[12] == rfcomm_dcid[0] && l2capinbuf[13] == rfcomm_dcid[1]) {
168 identifier = l2capinbuf[9];
172 if (l2capinbuf[12] == sdp_scid[0] && l2capinbuf[13] == sdp_scid[1]) {
174 identifier = l2capinbuf[9];
176 }
else if (l2capinbuf[12] == rfcomm_scid[0] && l2capinbuf[13] == rfcomm_scid[1]) {
178 identifier = l2capinbuf[9];
182 #ifdef DEBUG_USB_HOST
183 Notify(PSTR(
"\r\nInformation request"), 0x80);
185 identifier = l2capinbuf[9];
190 Notify(PSTR(
"\r\nL2CAP Unknown Signaling Command: "), 0x80);
191 D_PrintHex<uint8_t > (l2capinbuf[8], 0x80);
194 }
else if (l2capinbuf[6] == sdp_dcid[0] && l2capinbuf[7] == sdp_dcid[1]) {
196 if (((l2capinbuf[16] << 8 | l2capinbuf[17]) ==
SERIALPORT_UUID) || ((l2capinbuf[16] << 8 | l2capinbuf[17]) == 0x0000 && (l2capinbuf[18] << 8 | l2capinbuf[19]) ==
SERIALPORT_UUID)) {
198 serialPortResponse1(l2capinbuf[9], l2capinbuf[10]);
199 firstMessage =
false;
201 serialPortResponse2(l2capinbuf[9], l2capinbuf[10]);
204 }
else if (((l2capinbuf[16] << 8 | l2capinbuf[17]) ==
L2CAP_UUID) || ((l2capinbuf[16] << 8 | l2capinbuf[17]) == 0x0000 && (l2capinbuf[18] << 8 | l2capinbuf[19]) ==
L2CAP_UUID)) {
206 l2capResponse1(l2capinbuf[9], l2capinbuf[10]);
207 firstMessage =
false;
209 l2capResponse2(l2capinbuf[9], l2capinbuf[10]);
213 serviceNotSupported(l2capinbuf[9], l2capinbuf[10]);
215 Notify(PSTR(
"\r\nUUID: "), 0x80);
217 if((l2capinbuf[16] << 8 | l2capinbuf[17]) == 0x0000)
218 uuid = (l2capinbuf[18] << 8 | l2capinbuf[19]);
220 uuid = (l2capinbuf[16] << 8 | l2capinbuf[17]);
221 D_PrintHex<uint16_t> (uuid, 0x80);
223 Notify(PSTR(
"\r\nLength: "), 0x80);
224 uint16_t length = l2capinbuf[11] << 8 | l2capinbuf[12];
225 D_PrintHex<uint16_t> (length, 0x80);
226 Notify(PSTR(
"\r\nData: "), 0x80);
227 for (uint8_t i = 0; i < length; i++) {
228 D_PrintHex<uint8_t> (l2capinbuf[13+i], 0x80);
235 Notify(PSTR(
"\r\nUnknown PDU: "), 0x80);
236 D_PrintHex<uint8_t > (l2capinbuf[8], 0x80);
239 }
else if (l2capinbuf[6] == rfcomm_dcid[0] && l2capinbuf[7] == rfcomm_dcid[1]) {
240 rfcommChannel = l2capinbuf[8] & 0xF8;
241 rfcommDirection = l2capinbuf[8] & 0x04;
242 rfcommCommandResponse = l2capinbuf[8] & 0x02;
243 rfcommChannelType = l2capinbuf[9] & 0xEF;
244 rfcommPfBit = l2capinbuf[9] & 0x10;
246 if (rfcommChannel >> 3 != 0x00)
247 rfcommChannelConnection = rfcommChannel;
250 Notify(PSTR(
"\r\nRFCOMM Channel: "), 0x80);
251 D_PrintHex<uint8_t > (rfcommChannel >> 3, 0x80);
252 Notify(PSTR(
" Direction: "), 0x80);
253 D_PrintHex<uint8_t > (rfcommDirection >> 2, 0x80);
254 Notify(PSTR(
" CommandResponse: "), 0x80);
255 D_PrintHex<uint8_t > (rfcommCommandResponse >> 1, 0x80);
256 Notify(PSTR(
" ChannelType: "), 0x80);
257 D_PrintHex<uint8_t > (rfcommChannelType, 0x80);
258 Notify(PSTR(
" PF_BIT: "), 0x80);
259 D_PrintHex<uint8_t > (rfcommPfBit, 0x80);
262 #ifdef DEBUG_USB_HOST
263 Notify(PSTR(
"\r\nReceived Disconnect RFCOMM Command on channel: "), 0x80);
264 D_PrintHex<uint8_t > (rfcommChannel >> 3, 0x80);
267 sendRfcomm(rfcommChannel, rfcommDirection, rfcommCommandResponse,
RFCOMM_UA, rfcommPfBit, rfcommbuf, 0x00);
271 if (rfcommChannelType ==
RFCOMM_UIH && rfcommChannel == rfcommChannelConnection) {
272 uint8_t length = l2capinbuf[10] >> 1;
273 uint8_t offset = l2capinbuf[4] - length - 4;
274 if (checkFcs(&l2capinbuf[8], l2capinbuf[11 + length + offset])) {
276 for (; i < length; i++) {
277 if (rfcommAvailable + i >=
sizeof (rfcommDataBuffer)) {
278 #ifdef DEBUG_USB_HOST
279 Notify(PSTR(
"\r\nWarning: Buffer is full!"), 0x80);
283 rfcommDataBuffer[rfcommAvailable + i] = l2capinbuf[11 + i + offset];
285 rfcommAvailable += i;
287 Notify(PSTR(
"\r\nRFCOMM Data Available: "), 0x80);
288 Notify(rfcommAvailable, 0x80);
290 Notify(PSTR(
" - Credit: 0x"), 0x80);
291 D_PrintHex<uint8_t > (l2capinbuf[11], 0x80);
295 #ifdef DEBUG_USB_HOST
297 Notify(PSTR(
"\r\nError in FCS checksum!"), 0x80);
299 #ifdef PRINTREPORT // Uncomment "#define PRINTREPORT" to print the report send to the Arduino via Bluetooth
300 for (uint8_t i = 0; i < length; i++)
301 Notifyc(l2capinbuf[i + 11 + offset], 0x80);
304 #ifdef DEBUG_USB_HOST
305 Notify(PSTR(
"\r\nReceived UIH Remote Port Negotiation Command"), 0x80);
308 rfcommbuf[1] = l2capinbuf[12];
309 rfcommbuf[2] = l2capinbuf[13];
310 rfcommbuf[3] = l2capinbuf[14];
311 rfcommbuf[4] = l2capinbuf[15];
312 rfcommbuf[5] = l2capinbuf[16];
313 rfcommbuf[6] = l2capinbuf[17];
314 rfcommbuf[7] = l2capinbuf[18];
315 rfcommbuf[8] = l2capinbuf[19];
316 rfcommbuf[9] = l2capinbuf[20];
317 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x0A);
319 #ifdef DEBUG_USB_HOST
320 Notify(PSTR(
"\r\nSend UIH Modem Status Response"), 0x80);
323 rfcommbuf[1] = 2 << 1 | 1;
324 rfcommbuf[2] = l2capinbuf[13];
325 rfcommbuf[3] = l2capinbuf[14];
326 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x04);
330 #ifdef DEBUG_USB_HOST
331 Notify(PSTR(
"\r\nReceived SABM Command"), 0x80);
333 sendRfcomm(rfcommChannel, rfcommDirection, rfcommCommandResponse,
RFCOMM_UA, rfcommPfBit, rfcommbuf, 0x00);
335 #ifdef DEBUG_USB_HOST
336 Notify(PSTR(
"\r\nReceived UIH Parameter Negotiation Command"), 0x80);
339 rfcommbuf[1] = l2capinbuf[12];
340 rfcommbuf[2] = l2capinbuf[13];
348 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x0A);
350 #ifdef DEBUG_USB_HOST
351 Notify(PSTR(
"\r\nSend UIH Modem Status Response"), 0x80);
354 rfcommbuf[1] = 2 << 1 | 1;
355 rfcommbuf[2] = l2capinbuf[13];
356 rfcommbuf[3] = l2capinbuf[14];
357 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x04);
360 #ifdef DEBUG_USB_HOST
361 Notify(PSTR(
"\r\nSend UIH Modem Status Command"), 0x80);
364 rfcommbuf[1] = 2 << 1 | 1;
365 rfcommbuf[2] = l2capinbuf[13];
368 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x04);
371 #ifdef DEBUG_USB_HOST
372 Notify(PSTR(
"\r\nSend UIH Command with credit"), 0x80);
374 sendRfcommCredit(rfcommChannelConnection, rfcommDirection, 0,
RFCOMM_UIH, 0x10,
sizeof (rfcommDataBuffer));
377 waitForLastCommand =
true;
379 }
else if (rfcommChannelType ==
RFCOMM_UIH && l2capinbuf[10] == 0x01) {
380 #ifdef DEBUG_USB_HOST
381 Notify(PSTR(
"\r\nReceived UIH Command with credit"), 0x80);
384 #ifdef DEBUG_USB_HOST
385 Notify(PSTR(
"\r\nReceived UIH Remote Port Negotiation Command"), 0x80);
388 rfcommbuf[1] = l2capinbuf[12];
389 rfcommbuf[2] = l2capinbuf[13];
390 rfcommbuf[3] = l2capinbuf[14];
391 rfcommbuf[4] = l2capinbuf[15];
392 rfcommbuf[5] = l2capinbuf[16];
393 rfcommbuf[6] = l2capinbuf[17];
394 rfcommbuf[7] = l2capinbuf[18];
395 rfcommbuf[8] = l2capinbuf[19];
396 rfcommbuf[9] = l2capinbuf[20];
397 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x0A);
398 #ifdef DEBUG_USB_HOST
399 Notify(PSTR(
"\r\nRFCOMM Connection is now established\r\n"), 0x80);
401 waitForLastCommand =
false;
406 #ifdef DEBUG_USB_HOST
408 Notify(PSTR(
"\r\nUnsupported RFCOMM Data - ChannelType: "), 0x80);
409 D_PrintHex<uint8_t > (rfcommChannelType, 0x80);
410 Notify(PSTR(
" Command: "), 0x80);
411 D_PrintHex<uint8_t > (l2capinbuf[11], 0x80);
418 Notify(PSTR(
"\r\nUnsupported L2CAP Data - Channel ID: "), 0x80);
419 D_PrintHex<uint8_t > (l2capinbuf[7], 0x80);
421 D_PrintHex<uint8_t > (l2capinbuf[6], 0x80);
430 if (waitForLastCommand && (millis() - timer) > 100) {
431 #ifdef DEBUG_USB_HOST
432 Notify(PSTR(
"\r\nRFCOMM Connection is now established - Automatic\r\n"), 0x80);
435 waitForLastCommand =
false;
442 void SPP::SDP_task() {
443 switch (l2cap_sdp_state) {
447 #ifdef DEBUG_USB_HOST
448 Notify(PSTR(
"\r\nSDP Incoming Connection Request"), 0x80);
462 #ifdef DEBUG_USB_HOST
463 Notify(PSTR(
"\r\nSDP Configuration Request"), 0x80);
472 #ifdef DEBUG_USB_HOST
473 Notify(PSTR(
"\r\nSDP Successfully Configured"), 0x80);
483 SDPConnected =
false;
484 #ifdef DEBUG_USB_HOST
485 Notify(PSTR(
"\r\nDisconnected SDP Channel"), 0x80);
494 #ifdef DEBUG_USB_HOST
495 Notify(PSTR(
"\r\nDisconnected L2CAP Connection"), 0x80);
497 RFCOMMConnected =
false;
498 SDPConnected =
false;
501 l2cap_event_flag = 0;
509 void SPP::RFCOMM_task() {
510 switch (l2cap_rfcomm_state) {
514 #ifdef DEBUG_USB_HOST
515 Notify(PSTR(
"\r\nRFCOMM Incoming Connection Request"), 0x80);
529 #ifdef DEBUG_USB_HOST
530 Notify(PSTR(
"\r\nRFCOMM Configuration Request"), 0x80);
539 #ifdef DEBUG_USB_HOST
540 Notify(PSTR(
"\r\nRFCOMM Successfully Configured"), 0x80);
544 RFCOMMConnected =
true;
551 RFCOMMConnected =
false;
553 #ifdef DEBUG_USB_HOST
554 Notify(PSTR(
"\r\nDisconnected RFCOMM Channel"), 0x80);
567 void SPP::SDP_Command(uint8_t* data, uint8_t nbytes) {
568 pBtd->
L2CAP_Command(hci_handle, data, nbytes, sdp_scid[0], sdp_scid[1]);
571 void SPP::serviceNotSupported(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
573 l2capoutbuf[1] = transactionIDHigh;
574 l2capoutbuf[2] = transactionIDLow;
575 l2capoutbuf[3] = 0x00;
576 l2capoutbuf[4] = 0x05;
577 l2capoutbuf[5] = 0x00;
578 l2capoutbuf[6] = 0x02;
581 l2capoutbuf[7] = 0x35;
582 l2capoutbuf[8] = 0x00;
583 l2capoutbuf[9] = 0x00;
585 SDP_Command(l2capoutbuf, 10);
588 void SPP::serialPortResponse1(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
590 l2capoutbuf[1] = transactionIDHigh;
591 l2capoutbuf[2] = transactionIDLow;
592 l2capoutbuf[3] = 0x00;
593 l2capoutbuf[4] = 0x2B;
594 l2capoutbuf[5] = 0x00;
595 l2capoutbuf[6] = 0x26;
598 l2capoutbuf[7] = 0x36;
599 l2capoutbuf[8] = 0x00;
600 l2capoutbuf[9] = 0x3C;
601 l2capoutbuf[10] = 0x36;
602 l2capoutbuf[11] = 0x00;
604 l2capoutbuf[12] = 0x39;
605 l2capoutbuf[13] = 0x09;
606 l2capoutbuf[14] = 0x00;
607 l2capoutbuf[15] = 0x00;
608 l2capoutbuf[16] = 0x0A;
609 l2capoutbuf[17] = 0x00;
610 l2capoutbuf[18] = 0x01;
611 l2capoutbuf[19] = 0x00;
612 l2capoutbuf[20] = 0x06;
613 l2capoutbuf[21] = 0x09;
614 l2capoutbuf[22] = 0x00;
615 l2capoutbuf[23] = 0x01;
616 l2capoutbuf[24] = 0x35;
617 l2capoutbuf[25] = 0x03;
618 l2capoutbuf[26] = 0x19;
619 l2capoutbuf[27] = 0x11;
621 l2capoutbuf[28] = 0x01;
622 l2capoutbuf[29] = 0x09;
623 l2capoutbuf[30] = 0x00;
624 l2capoutbuf[31] = 0x04;
625 l2capoutbuf[32] = 0x35;
626 l2capoutbuf[33] = 0x0C;
627 l2capoutbuf[34] = 0x35;
628 l2capoutbuf[35] = 0x03;
629 l2capoutbuf[36] = 0x19;
630 l2capoutbuf[37] = 0x01;
631 l2capoutbuf[38] = 0x00;
632 l2capoutbuf[39] = 0x35;
633 l2capoutbuf[40] = 0x05;
634 l2capoutbuf[41] = 0x19;
635 l2capoutbuf[42] = 0x00;
636 l2capoutbuf[43] = 0x03;
638 l2capoutbuf[44] = 0x08;
639 l2capoutbuf[45] = 0x02;
640 l2capoutbuf[46] = 0x00;
641 l2capoutbuf[47] = 0x19;
643 SDP_Command(l2capoutbuf, 48);
646 void SPP::serialPortResponse2(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
648 l2capoutbuf[1] = transactionIDHigh;
649 l2capoutbuf[2] = transactionIDLow;
650 l2capoutbuf[3] = 0x00;
651 l2capoutbuf[4] = 0x1C;
652 l2capoutbuf[5] = 0x00;
653 l2capoutbuf[6] = 0x19;
656 l2capoutbuf[7] = 0x01;
657 l2capoutbuf[8] = 0x09;
658 l2capoutbuf[9] = 0x00;
659 l2capoutbuf[10] = 0x06;
660 l2capoutbuf[11] = 0x35;
662 l2capoutbuf[12] = 0x09;
663 l2capoutbuf[13] = 0x09;
664 l2capoutbuf[14] = 0x65;
665 l2capoutbuf[15] = 0x6E;
666 l2capoutbuf[16] = 0x09;
667 l2capoutbuf[17] = 0x00;
668 l2capoutbuf[18] = 0x6A;
669 l2capoutbuf[19] = 0x09;
670 l2capoutbuf[20] = 0x01;
671 l2capoutbuf[21] = 0x00;
672 l2capoutbuf[22] = 0x09;
673 l2capoutbuf[23] = 0x01;
674 l2capoutbuf[24] = 0x00;
675 l2capoutbuf[25] = 0x25;
677 l2capoutbuf[26] = 0x05;
678 l2capoutbuf[27] =
'T';
679 l2capoutbuf[28] =
'K';
680 l2capoutbuf[29] =
'J';
681 l2capoutbuf[30] =
'S';
682 l2capoutbuf[31] =
'P';
683 l2capoutbuf[32] = 0x00;
685 SDP_Command(l2capoutbuf, 33);
688 void SPP::l2capResponse1(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
689 serialPortResponse1(transactionIDHigh, transactionIDLow);
692 void SPP::l2capResponse2(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
693 serialPortResponse2(transactionIDHigh, transactionIDLow);
699 void SPP::RFCOMM_Command(uint8_t* data, uint8_t nbytes) {
700 pBtd->
L2CAP_Command(hci_handle, data, nbytes, rfcomm_scid[0], rfcomm_scid[1]);
703 void SPP::sendRfcomm(uint8_t channel, uint8_t direction, uint8_t CR, uint8_t channelType, uint8_t pfBit, uint8_t* data, uint8_t length) {
705 l2capoutbuf[1] = channelType | pfBit;
706 l2capoutbuf[2] = length << 1 | 0x01;
708 for (; i < length; i++)
709 l2capoutbuf[i + 3] = data[i];
710 l2capoutbuf[i + 3] = calcFcs(l2capoutbuf);
712 Notify(PSTR(
" - RFCOMM Data: "), 0x80);
713 for (i = 0; i < length + 4; i++) {
714 D_PrintHex<uint8_t > (l2capoutbuf[i], 0x80);
718 RFCOMM_Command(l2capoutbuf, length + 4);
721 void SPP::sendRfcommCredit(uint8_t channel, uint8_t direction, uint8_t CR, uint8_t channelType, uint8_t pfBit, uint8_t credit) {
723 l2capoutbuf[1] = channelType | pfBit;
724 l2capoutbuf[2] = 0x01;
725 l2capoutbuf[3] = credit;
726 l2capoutbuf[4] = calcFcs(l2capoutbuf);
728 Notify(PSTR(
" - RFCOMM Credit Data: "), 0x80);
729 for (uint8_t i = 0; i < 5; i++) {
730 D_PrintHex<uint8_t > (l2capoutbuf[i], 0x80);
734 RFCOMM_Command(l2capoutbuf, 5);
738 uint8_t SPP::crc(uint8_t *data) {
743 uint8_t SPP::calcFcs(uint8_t *data) {
745 return (0xFF - crc(data));
751 bool SPP::checkFcs(uint8_t *data, uint8_t fcs) {
752 uint8_t temp = crc(data);
760 return write(&data,1);
764 for(uint8_t i = 0; i < size; i++) {
765 if(sppIndex >=
sizeof(sppOutputBuffer)/
sizeof(sppOutputBuffer[0]))
767 sppOutputBuffer[sppIndex++] = data[i];
778 l2capoutbuf[0] = rfcommChannelConnection | 0 | 0 |
extendAddress;
782 if (sppIndex > (
sizeof (l2capoutbuf) - 4))
783 length =
sizeof (l2capoutbuf) - 4;
787 l2capoutbuf[2] = length << 1 | 1;
789 for (; i < length; i++)
790 l2capoutbuf[i + 3] = sppOutputBuffer[i + offset];
791 l2capoutbuf[i + 3] = calcFcs(l2capoutbuf);
793 RFCOMM_Command(l2capoutbuf, length + 4);
801 return rfcommAvailable;
809 if (rfcommAvailable == 0)
811 return rfcommDataBuffer[0];
815 if (rfcommAvailable == 0)
817 uint8_t output = rfcommDataBuffer[0];
818 for (uint8_t i = 1; i < rfcommAvailable; i++)
819 rfcommDataBuffer[i - 1] = rfcommDataBuffer[i];
822 if (bytesRead > (
sizeof (rfcommDataBuffer) - 5)) {
824 sendRfcommCredit(rfcommChannelConnection, rfcommDirection, 0,
RFCOMM_UIH, 0x10,
sizeof (rfcommDataBuffer));
826 Notify(PSTR(
"\r\nSent "), 0x80);
827 Notify((uint8_t)
sizeof (rfcommDataBuffer), 0x80);
828 Notify(PSTR(
" more credit"), 0x80);
virtual size_t write(uint8_t data)
#define BT_RFCOMM_RPN_RSP
void l2cap_connection_response(uint16_t handle, uint8_t rxid, uint8_t *dcid, uint8_t *scid, uint8_t result)
bool sdpConnectionClaimed
#define L2CAP_FLAG_CONFIG_SDP_REQUEST
void l2cap_disconnection_request(uint16_t handle, uint8_t rxid, uint8_t *dcid, uint8_t *scid)
const uint8_t rfcomm_crc_table[256]
bool rfcommConnectionClaimed
#define SDP_SERVICE_SEARCH_ATTRIBUTE_RESPONSE_PDU
#define l2cap_connection_request_sdp_flag
#define L2CAP_FLAG_CONNECTION_SDP_REQUEST
#define l2cap_disconnect_response_flag
#define L2CAP_FLAG_CONFIG_RFCOMM_SUCCESS
#define L2CAP_DISCONNECT_RESPONSE
#define L2CAP_FLAG_CONFIG_RFCOMM_REQUEST
#define L2CAP_CMD_INFORMATION_REQUEST
#define l2cap_config_request_sdp_flag
void l2cap_disconnection_response(uint16_t handle, uint8_t rxid, uint8_t *dcid, uint8_t *scid)
#define L2CAP_SDP_REQUEST
#define l2cap_connection_request_rfcomm_flag
#define L2CAP_FLAG_CONFIG_SDP_SUCCESS
#define L2CAP_FLAG_DISCONNECT_RFCOMM_REQUEST
void hci_disconnect(uint16_t handle)
#define l2cap_config_success_rfcomm_flag
SPP(BTD *p, const char *name="Arduino", const char *pin="1234")
virtual int available(void)
#define l2cap_disconnect_request_rfcomm_flag
#define L2CAP_SDP_SUCCESS
#define L2CAP_CMD_CONFIG_REQUEST
#define L2CAP_CMD_DISCONNECT_REQUEST
#define L2CAP_FLAG_DISCONNECT_SDP_REQUEST
#define L2CAP_RFCOMM_DONE
#define BT_RFCOMM_RPN_CMD
int8_t registerServiceClass(BluetoothService *pService)
virtual void disconnect()
#define BT_RFCOMM_MSC_CMD
#define SDP_SERVICE_SEARCH_ATTRIBUTE_REQUEST_PDU
#define L2CAP_CMD_DISCONNECT_RESPONSE
void l2cap_information_response(uint16_t handle, uint8_t rxid, uint8_t infoTypeLow, uint8_t infoTypeHigh)
#define L2CAP_CMD_CONFIG_RESPONSE
#define L2CAP_FLAG_CONNECTION_RFCOMM_REQUEST
#define L2CAP_RFCOMM_SUCCESS
#define BT_RFCOMM_MSC_RSP
#define L2CAP_RFCOMM_REQUEST
#define L2CAP_RFCOMM_WAIT
void L2CAP_Command(uint16_t handle, uint8_t *data, uint8_t nbytes, uint8_t channelLow=0x01, uint8_t channelHigh=0x00)
void l2cap_config_response(uint16_t handle, uint8_t rxid, uint8_t *scid)
void l2cap_config_request(uint16_t handle, uint8_t rxid, uint8_t *dcid)
#define l2cap_config_request_rfcomm_flag
#define L2CAP_CMD_CONNECTION_REQUEST
#define l2cap_config_success_sdp_flag
#define l2cap_disconnect_request_sdp_flag
virtual void ACLData(uint8_t *ACLData)
#define L2CAP_FLAG_DISCONNECT_RESPONSE
#define L2CAP_CMD_COMMAND_REJECT