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)
102 if((l2capinbuf[6] | (l2capinbuf[7] << 8)) == 0x0001U) {
104 #ifdef DEBUG_USB_HOST
105 Notify(PSTR(
"\r\nL2CAP Command Rejected - Reason: "), 0x80);
106 D_PrintHex<uint8_t > (l2capinbuf[13], 0x80);
108 D_PrintHex<uint8_t > (l2capinbuf[12], 0x80);
109 Notify(PSTR(
" Data: "), 0x80);
110 D_PrintHex<uint8_t > (l2capinbuf[17], 0x80);
112 D_PrintHex<uint8_t > (l2capinbuf[16], 0x80);
114 D_PrintHex<uint8_t > (l2capinbuf[15], 0x80);
116 D_PrintHex<uint8_t > (l2capinbuf[14], 0x80);
120 Notify(PSTR(
"\r\nL2CAP Connection Request - PSM: "), 0x80);
121 D_PrintHex<uint8_t > (l2capinbuf[13], 0x80);
123 D_PrintHex<uint8_t > (l2capinbuf[12], 0x80);
124 Notify(PSTR(
" SCID: "), 0x80);
125 D_PrintHex<uint8_t > (l2capinbuf[15], 0x80);
127 D_PrintHex<uint8_t > (l2capinbuf[14], 0x80);
128 Notify(PSTR(
" Identifier: "), 0x80);
129 D_PrintHex<uint8_t > (l2capinbuf[9], 0x80);
131 if((l2capinbuf[12] | (l2capinbuf[13] << 8)) ==
SDP_PSM) {
132 identifier = l2capinbuf[9];
133 sdp_scid[0] = l2capinbuf[14];
134 sdp_scid[1] = l2capinbuf[15];
136 }
else if((l2capinbuf[12] | (l2capinbuf[13] << 8)) ==
RFCOMM_PSM) {
137 identifier = l2capinbuf[9];
138 rfcomm_scid[0] = l2capinbuf[14];
139 rfcomm_scid[1] = l2capinbuf[15];
143 if((l2capinbuf[16] | (l2capinbuf[17] << 8)) == 0x0000) {
144 if(l2capinbuf[12] == sdp_dcid[0] && l2capinbuf[13] == sdp_dcid[1]) {
147 }
else if(l2capinbuf[12] == rfcomm_dcid[0] && l2capinbuf[13] == rfcomm_dcid[1]) {
153 if(l2capinbuf[12] == sdp_dcid[0] && l2capinbuf[13] == sdp_dcid[1]) {
156 }
else if(l2capinbuf[12] == rfcomm_dcid[0] && l2capinbuf[13] == rfcomm_dcid[1]) {
161 if(l2capinbuf[12] == sdp_dcid[0] && l2capinbuf[13] == sdp_dcid[1]) {
163 identifier = l2capinbuf[9];
165 }
else if(l2capinbuf[12] == rfcomm_dcid[0] && l2capinbuf[13] == rfcomm_dcid[1]) {
167 identifier = l2capinbuf[9];
171 if(l2capinbuf[12] == sdp_scid[0] && l2capinbuf[13] == sdp_scid[1]) {
173 identifier = l2capinbuf[9];
175 }
else if(l2capinbuf[12] == rfcomm_scid[0] && l2capinbuf[13] == rfcomm_scid[1]) {
177 identifier = l2capinbuf[9];
181 #ifdef DEBUG_USB_HOST
182 Notify(PSTR(
"\r\nInformation request"), 0x80);
184 identifier = l2capinbuf[9];
189 Notify(PSTR(
"\r\nL2CAP Unknown Signaling Command: "), 0x80);
190 D_PrintHex<uint8_t > (l2capinbuf[8], 0x80);
193 }
else if(l2capinbuf[6] == sdp_dcid[0] && l2capinbuf[7] == sdp_dcid[1]) {
195 if(((l2capinbuf[16] << 8 | l2capinbuf[17]) ==
SERIALPORT_UUID) || ((l2capinbuf[16] << 8 | l2capinbuf[17]) == 0x0000 && (l2capinbuf[18] << 8 | l2capinbuf[19]) ==
SERIALPORT_UUID)) {
197 serialPortResponse1(l2capinbuf[9], l2capinbuf[10]);
198 firstMessage =
false;
200 serialPortResponse2(l2capinbuf[9], l2capinbuf[10]);
203 }
else if(((l2capinbuf[16] << 8 | l2capinbuf[17]) ==
L2CAP_UUID) || ((l2capinbuf[16] << 8 | l2capinbuf[17]) == 0x0000 && (l2capinbuf[18] << 8 | l2capinbuf[19]) ==
L2CAP_UUID)) {
205 l2capResponse1(l2capinbuf[9], l2capinbuf[10]);
206 firstMessage =
false;
208 l2capResponse2(l2capinbuf[9], l2capinbuf[10]);
212 serviceNotSupported(l2capinbuf[9], l2capinbuf[10]);
214 Notify(PSTR(
"\r\nUUID: "), 0x80);
216 if((l2capinbuf[16] << 8 | l2capinbuf[17]) == 0x0000)
217 uuid = (l2capinbuf[18] << 8 | l2capinbuf[19]);
219 uuid = (l2capinbuf[16] << 8 | l2capinbuf[17]);
220 D_PrintHex<uint16_t > (uuid, 0x80);
222 Notify(PSTR(
"\r\nLength: "), 0x80);
223 uint16_t length = l2capinbuf[11] << 8 | l2capinbuf[12];
224 D_PrintHex<uint16_t > (length, 0x80);
225 Notify(PSTR(
"\r\nData: "), 0x80);
226 for(uint8_t i = 0; i < length; i++) {
227 D_PrintHex<uint8_t > (l2capinbuf[13 + i], 0x80);
234 Notify(PSTR(
"\r\nUnknown PDU: "), 0x80);
235 D_PrintHex<uint8_t > (l2capinbuf[8], 0x80);
238 }
else if(l2capinbuf[6] == rfcomm_dcid[0] && l2capinbuf[7] == rfcomm_dcid[1]) {
239 rfcommChannel = l2capinbuf[8] & 0xF8;
240 rfcommDirection = l2capinbuf[8] & 0x04;
241 rfcommCommandResponse = l2capinbuf[8] & 0x02;
242 rfcommChannelType = l2capinbuf[9] & 0xEF;
243 rfcommPfBit = l2capinbuf[9] & 0x10;
245 if(rfcommChannel >> 3 != 0x00)
246 rfcommChannelConnection = rfcommChannel;
249 Notify(PSTR(
"\r\nRFCOMM Channel: "), 0x80);
250 D_PrintHex<uint8_t > (rfcommChannel >> 3, 0x80);
251 Notify(PSTR(
" Direction: "), 0x80);
252 D_PrintHex<uint8_t > (rfcommDirection >> 2, 0x80);
253 Notify(PSTR(
" CommandResponse: "), 0x80);
254 D_PrintHex<uint8_t > (rfcommCommandResponse >> 1, 0x80);
255 Notify(PSTR(
" ChannelType: "), 0x80);
256 D_PrintHex<uint8_t > (rfcommChannelType, 0x80);
257 Notify(PSTR(
" PF_BIT: "), 0x80);
258 D_PrintHex<uint8_t > (rfcommPfBit, 0x80);
261 #ifdef DEBUG_USB_HOST
262 Notify(PSTR(
"\r\nReceived Disconnect RFCOMM Command on channel: "), 0x80);
263 D_PrintHex<uint8_t > (rfcommChannel >> 3, 0x80);
266 sendRfcomm(rfcommChannel, rfcommDirection, rfcommCommandResponse,
RFCOMM_UA, rfcommPfBit, rfcommbuf, 0x00);
270 if(rfcommChannelType ==
RFCOMM_UIH && rfcommChannel == rfcommChannelConnection) {
271 uint8_t length = l2capinbuf[10] >> 1;
272 uint8_t offset = l2capinbuf[4] - length - 4;
273 if(checkFcs(&l2capinbuf[8], l2capinbuf[11 + length + offset])) {
275 for(; i < length; i++) {
276 if(rfcommAvailable + i >=
sizeof (rfcommDataBuffer)) {
277 #ifdef DEBUG_USB_HOST
278 Notify(PSTR(
"\r\nWarning: Buffer is full!"), 0x80);
282 rfcommDataBuffer[rfcommAvailable + i] = l2capinbuf[11 + i + offset];
284 rfcommAvailable += i;
286 Notify(PSTR(
"\r\nRFCOMM Data Available: "), 0x80);
287 Notify(rfcommAvailable, 0x80);
289 Notify(PSTR(
" - Credit: 0x"), 0x80);
290 D_PrintHex<uint8_t > (l2capinbuf[11], 0x80);
294 #ifdef DEBUG_USB_HOST
296 Notify(PSTR(
"\r\nError in FCS checksum!"), 0x80);
298 #ifdef PRINTREPORT // Uncomment "#define PRINTREPORT" to print the report send to the Arduino via Bluetooth
299 for(uint8_t i = 0; i < length; i++)
300 Notifyc(l2capinbuf[i + 11 + offset], 0x80);
303 #ifdef DEBUG_USB_HOST
304 Notify(PSTR(
"\r\nReceived UIH Remote Port Negotiation Command"), 0x80);
307 rfcommbuf[1] = l2capinbuf[12];
308 rfcommbuf[2] = l2capinbuf[13];
309 rfcommbuf[3] = l2capinbuf[14];
310 rfcommbuf[4] = l2capinbuf[15];
311 rfcommbuf[5] = l2capinbuf[16];
312 rfcommbuf[6] = l2capinbuf[17];
313 rfcommbuf[7] = l2capinbuf[18];
314 rfcommbuf[8] = l2capinbuf[19];
315 rfcommbuf[9] = l2capinbuf[20];
316 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x0A);
318 #ifdef DEBUG_USB_HOST
319 Notify(PSTR(
"\r\nSend UIH Modem Status Response"), 0x80);
322 rfcommbuf[1] = 2 << 1 | 1;
323 rfcommbuf[2] = l2capinbuf[13];
324 rfcommbuf[3] = l2capinbuf[14];
325 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x04);
329 #ifdef DEBUG_USB_HOST
330 Notify(PSTR(
"\r\nReceived SABM Command"), 0x80);
332 sendRfcomm(rfcommChannel, rfcommDirection, rfcommCommandResponse,
RFCOMM_UA, rfcommPfBit, rfcommbuf, 0x00);
334 #ifdef DEBUG_USB_HOST
335 Notify(PSTR(
"\r\nReceived UIH Parameter Negotiation Command"), 0x80);
338 rfcommbuf[1] = l2capinbuf[12];
339 rfcommbuf[2] = l2capinbuf[13];
347 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x0A);
349 #ifdef DEBUG_USB_HOST
350 Notify(PSTR(
"\r\nSend UIH Modem Status Response"), 0x80);
353 rfcommbuf[1] = 2 << 1 | 1;
354 rfcommbuf[2] = l2capinbuf[13];
355 rfcommbuf[3] = l2capinbuf[14];
356 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x04);
359 #ifdef DEBUG_USB_HOST
360 Notify(PSTR(
"\r\nSend UIH Modem Status Command"), 0x80);
363 rfcommbuf[1] = 2 << 1 | 1;
364 rfcommbuf[2] = l2capinbuf[13];
367 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x04);
370 #ifdef DEBUG_USB_HOST
371 Notify(PSTR(
"\r\nSend UIH Command with credit"), 0x80);
373 sendRfcommCredit(rfcommChannelConnection, rfcommDirection, 0,
RFCOMM_UIH, 0x10,
sizeof (rfcommDataBuffer));
376 waitForLastCommand =
true;
378 }
else if(rfcommChannelType ==
RFCOMM_UIH && l2capinbuf[10] == 0x01) {
379 #ifdef DEBUG_USB_HOST
380 Notify(PSTR(
"\r\nReceived UIH Command with credit"), 0x80);
383 #ifdef DEBUG_USB_HOST
384 Notify(PSTR(
"\r\nReceived UIH Remote Port Negotiation Command"), 0x80);
387 rfcommbuf[1] = l2capinbuf[12];
388 rfcommbuf[2] = l2capinbuf[13];
389 rfcommbuf[3] = l2capinbuf[14];
390 rfcommbuf[4] = l2capinbuf[15];
391 rfcommbuf[5] = l2capinbuf[16];
392 rfcommbuf[6] = l2capinbuf[17];
393 rfcommbuf[7] = l2capinbuf[18];
394 rfcommbuf[8] = l2capinbuf[19];
395 rfcommbuf[9] = l2capinbuf[20];
396 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x0A);
397 #ifdef DEBUG_USB_HOST
398 Notify(PSTR(
"\r\nRFCOMM Connection is now established\r\n"), 0x80);
400 waitForLastCommand =
false;
407 Notify(PSTR(
"\r\nUnsupported RFCOMM Data - ChannelType: "), 0x80);
408 D_PrintHex<uint8_t > (rfcommChannelType, 0x80);
409 Notify(PSTR(
" Command: "), 0x80);
410 D_PrintHex<uint8_t > (l2capinbuf[11], 0x80);
417 Notify(PSTR(
"\r\nUnsupported L2CAP Data - Channel ID: "), 0x80);
418 D_PrintHex<uint8_t > (l2capinbuf[7], 0x80);
420 D_PrintHex<uint8_t > (l2capinbuf[6], 0x80);
429 if(waitForLastCommand && (millis() - timer) > 100) {
430 #ifdef DEBUG_USB_HOST
431 Notify(PSTR(
"\r\nRFCOMM Connection is now established - Automatic\r\n"), 0x80);
434 waitForLastCommand =
false;
441 void SPP::SDP_task() {
442 switch(l2cap_sdp_state) {
446 #ifdef DEBUG_USB_HOST
447 Notify(PSTR(
"\r\nSDP Incoming Connection Request"), 0x80);
458 SDPConnected =
false;
459 #ifdef DEBUG_USB_HOST
460 Notify(PSTR(
"\r\nDisconnected SDP Channel"), 0x80);
468 #ifdef DEBUG_USB_HOST
469 Notify(PSTR(
"\r\nSDP Successfully Configured"), 0x80);
479 #ifdef DEBUG_USB_HOST
480 Notify(PSTR(
"\r\nDisconnected L2CAP Connection"), 0x80);
490 void SPP::RFCOMM_task() {
491 switch(l2cap_rfcomm_state) {
495 #ifdef DEBUG_USB_HOST
496 Notify(PSTR(
"\r\nRFCOMM Incoming Connection Request"), 0x80);
507 RFCOMMConnected =
false;
509 #ifdef DEBUG_USB_HOST
510 Notify(PSTR(
"\r\nDisconnected RFCOMM Channel"), 0x80);
518 #ifdef DEBUG_USB_HOST
519 Notify(PSTR(
"\r\nRFCOMM Successfully Configured"), 0x80);
523 RFCOMMConnected =
true;
533 void SPP::SDP_Command(uint8_t* data, uint8_t nbytes) {
534 pBtd->
L2CAP_Command(hci_handle, data, nbytes, sdp_scid[0], sdp_scid[1]);
537 void SPP::serviceNotSupported(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
539 l2capoutbuf[1] = transactionIDHigh;
540 l2capoutbuf[2] = transactionIDLow;
541 l2capoutbuf[3] = 0x00;
542 l2capoutbuf[4] = 0x05;
543 l2capoutbuf[5] = 0x00;
544 l2capoutbuf[6] = 0x02;
547 l2capoutbuf[7] = 0x35;
548 l2capoutbuf[8] = 0x00;
549 l2capoutbuf[9] = 0x00;
551 SDP_Command(l2capoutbuf, 10);
554 void SPP::serialPortResponse1(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
556 l2capoutbuf[1] = transactionIDHigh;
557 l2capoutbuf[2] = transactionIDLow;
558 l2capoutbuf[3] = 0x00;
559 l2capoutbuf[4] = 0x2B;
560 l2capoutbuf[5] = 0x00;
561 l2capoutbuf[6] = 0x26;
564 l2capoutbuf[7] = 0x36;
565 l2capoutbuf[8] = 0x00;
566 l2capoutbuf[9] = 0x3C;
567 l2capoutbuf[10] = 0x36;
568 l2capoutbuf[11] = 0x00;
570 l2capoutbuf[12] = 0x39;
571 l2capoutbuf[13] = 0x09;
572 l2capoutbuf[14] = 0x00;
573 l2capoutbuf[15] = 0x00;
574 l2capoutbuf[16] = 0x0A;
575 l2capoutbuf[17] = 0x00;
576 l2capoutbuf[18] = 0x01;
577 l2capoutbuf[19] = 0x00;
578 l2capoutbuf[20] = 0x06;
579 l2capoutbuf[21] = 0x09;
580 l2capoutbuf[22] = 0x00;
581 l2capoutbuf[23] = 0x01;
582 l2capoutbuf[24] = 0x35;
583 l2capoutbuf[25] = 0x03;
584 l2capoutbuf[26] = 0x19;
585 l2capoutbuf[27] = 0x11;
587 l2capoutbuf[28] = 0x01;
588 l2capoutbuf[29] = 0x09;
589 l2capoutbuf[30] = 0x00;
590 l2capoutbuf[31] = 0x04;
591 l2capoutbuf[32] = 0x35;
592 l2capoutbuf[33] = 0x0C;
593 l2capoutbuf[34] = 0x35;
594 l2capoutbuf[35] = 0x03;
595 l2capoutbuf[36] = 0x19;
596 l2capoutbuf[37] = 0x01;
597 l2capoutbuf[38] = 0x00;
598 l2capoutbuf[39] = 0x35;
599 l2capoutbuf[40] = 0x05;
600 l2capoutbuf[41] = 0x19;
601 l2capoutbuf[42] = 0x00;
602 l2capoutbuf[43] = 0x03;
604 l2capoutbuf[44] = 0x08;
605 l2capoutbuf[45] = 0x02;
606 l2capoutbuf[46] = 0x00;
607 l2capoutbuf[47] = 0x19;
609 SDP_Command(l2capoutbuf, 48);
612 void SPP::serialPortResponse2(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
614 l2capoutbuf[1] = transactionIDHigh;
615 l2capoutbuf[2] = transactionIDLow;
616 l2capoutbuf[3] = 0x00;
617 l2capoutbuf[4] = 0x1C;
618 l2capoutbuf[5] = 0x00;
619 l2capoutbuf[6] = 0x19;
622 l2capoutbuf[7] = 0x01;
623 l2capoutbuf[8] = 0x09;
624 l2capoutbuf[9] = 0x00;
625 l2capoutbuf[10] = 0x06;
626 l2capoutbuf[11] = 0x35;
628 l2capoutbuf[12] = 0x09;
629 l2capoutbuf[13] = 0x09;
630 l2capoutbuf[14] = 0x65;
631 l2capoutbuf[15] = 0x6E;
632 l2capoutbuf[16] = 0x09;
633 l2capoutbuf[17] = 0x00;
634 l2capoutbuf[18] = 0x6A;
635 l2capoutbuf[19] = 0x09;
636 l2capoutbuf[20] = 0x01;
637 l2capoutbuf[21] = 0x00;
638 l2capoutbuf[22] = 0x09;
639 l2capoutbuf[23] = 0x01;
640 l2capoutbuf[24] = 0x00;
641 l2capoutbuf[25] = 0x25;
643 l2capoutbuf[26] = 0x05;
644 l2capoutbuf[27] =
'T';
645 l2capoutbuf[28] =
'K';
646 l2capoutbuf[29] =
'J';
647 l2capoutbuf[30] =
'S';
648 l2capoutbuf[31] =
'P';
649 l2capoutbuf[32] = 0x00;
651 SDP_Command(l2capoutbuf, 33);
654 void SPP::l2capResponse1(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
655 serialPortResponse1(transactionIDHigh, transactionIDLow);
658 void SPP::l2capResponse2(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
659 serialPortResponse2(transactionIDHigh, transactionIDLow);
665 void SPP::RFCOMM_Command(uint8_t* data, uint8_t nbytes) {
666 pBtd->
L2CAP_Command(hci_handle, data, nbytes, rfcomm_scid[0], rfcomm_scid[1]);
669 void SPP::sendRfcomm(uint8_t channel, uint8_t direction, uint8_t CR, uint8_t channelType, uint8_t pfBit, uint8_t* data, uint8_t length) {
671 l2capoutbuf[1] = channelType | pfBit;
672 l2capoutbuf[2] = length << 1 | 0x01;
674 for(; i < length; i++)
675 l2capoutbuf[i + 3] = data[i];
676 l2capoutbuf[i + 3] = calcFcs(l2capoutbuf);
678 Notify(PSTR(
" - RFCOMM Data: "), 0x80);
679 for(i = 0; i < length + 4; i++) {
680 D_PrintHex<uint8_t > (l2capoutbuf[i], 0x80);
684 RFCOMM_Command(l2capoutbuf, length + 4);
687 void SPP::sendRfcommCredit(uint8_t channel, uint8_t direction, uint8_t CR, uint8_t channelType, uint8_t pfBit, uint8_t credit) {
689 l2capoutbuf[1] = channelType | pfBit;
690 l2capoutbuf[2] = 0x01;
691 l2capoutbuf[3] = credit;
692 l2capoutbuf[4] = calcFcs(l2capoutbuf);
694 Notify(PSTR(
" - RFCOMM Credit Data: "), 0x80);
695 for(uint8_t i = 0; i < 5; i++) {
696 D_PrintHex<uint8_t > (l2capoutbuf[i], 0x80);
700 RFCOMM_Command(l2capoutbuf, 5);
704 uint8_t SPP::crc(uint8_t *data) {
709 uint8_t SPP::calcFcs(uint8_t *data) {
710 uint8_t temp = crc(data);
712 return (0xFF - temp);
718 bool SPP::checkFcs(uint8_t *data, uint8_t fcs) {
719 uint8_t temp = crc(data);
726 #if defined(ARDUINO) && ARDUINO >=100
729 return write(&data, 1);
738 #if defined(ARDUINO) && ARDUINO >=100
743 void SPP::write(
const uint8_t *data,
size_t size) {
745 for(uint8_t i = 0; i < size; i++) {
746 if(sppIndex >=
sizeof (sppOutputBuffer) /
sizeof (sppOutputBuffer[0]))
748 sppOutputBuffer[sppIndex++] = data[i];
750 #if defined(ARDUINO) && ARDUINO >=100
761 l2capoutbuf[0] = rfcommChannelConnection | 0 | 0 |
extendAddress;
765 if(sppIndex > (
sizeof (l2capoutbuf) - 4))
766 length =
sizeof (l2capoutbuf) - 4;
770 l2capoutbuf[2] = length << 1 | 1;
772 for(; i < length; i++)
773 l2capoutbuf[i + 3] = sppOutputBuffer[i + offset];
774 l2capoutbuf[i + 3] = calcFcs(l2capoutbuf);
776 RFCOMM_Command(l2capoutbuf, length + 4);
784 return rfcommAvailable;
792 if(rfcommAvailable == 0)
794 return rfcommDataBuffer[0];
798 if(rfcommAvailable == 0)
800 uint8_t output = rfcommDataBuffer[0];
801 for(uint8_t i = 1; i < rfcommAvailable; i++)
802 rfcommDataBuffer[i - 1] = rfcommDataBuffer[i];
805 if(bytesRead > (
sizeof (rfcommDataBuffer) - 5)) {
807 sendRfcommCredit(rfcommChannelConnection, rfcommDirection, 0,
RFCOMM_UIH, 0x10,
sizeof (rfcommDataBuffer));
809 Notify(PSTR(
"\r\nSent "), 0x80);
810 Notify((uint8_t)
sizeof (rfcommDataBuffer), 0x80);
811 Notify(PSTR(
" more credit"), 0x80);
#define UHS_ACL_HANDLE_OK(x, y)
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
SPP(BTD *p, const char *name="Arduino", const char *pin="0000")
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_FLAG_CONFIG_SDP_SUCCESS
#define L2CAP_SDP_SUCCESS
#define L2CAP_CMD_INFORMATION_REQUEST
void l2cap_disconnection_response(uint16_t handle, uint8_t rxid, uint8_t *dcid, uint8_t *scid)
#define L2CAP_RFCOMM_WAIT
#define L2CAP_FLAG_CONNECTION_RFCOMM_REQUEST
void hci_disconnect(uint16_t handle)
#define L2CAP_FLAG_DISCONNECT_SDP_REQUEST
virtual int available(void)
#define l2cap_check_flag(flag)
#define L2CAP_CMD_CONFIG_REQUEST
#define L2CAP_CMD_DISCONNECT_REQUEST
#define L2CAP_RFCOMM_SUCCESS
#define BT_RFCOMM_RPN_CMD
int8_t registerServiceClass(BluetoothService *pService)
#define L2CAP_FLAG_DISCONNECT_RESPONSE
#define L2CAP_FLAG_CONFIG_RFCOMM_SUCCESS
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 BT_RFCOMM_MSC_RSP
#define L2CAP_FLAG_CONNECTION_SDP_REQUEST
#define l2cap_clear_flag(flag)
#define L2CAP_FLAG_DISCONNECT_RFCOMM_REQUEST
#define L2CAP_DISCONNECT_RESPONSE
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)
#define l2cap_set_flag(flag)
void l2cap_config_request(uint16_t handle, uint8_t rxid, uint8_t *dcid)
#define L2CAP_CMD_CONNECTION_REQUEST
virtual void ACLData(uint8_t *ACLData)
#define L2CAP_CMD_COMMAND_REJECT