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
54 rfcomm_dcid[0] = 0x51;
55 rfcomm_dcid[1] = 0x00;
62 RFCOMMConnected =
false;
64 waitForLastCommand =
false;
77 if(RFCOMMConnected && SDPConnected)
100 if((l2capinbuf[6] | (l2capinbuf[7] << 8)) == 0x0001U) {
102 #ifdef DEBUG_USB_HOST
103 Notify(
PSTR(
"\r\nL2CAP Command Rejected - Reason: "), 0x80);
104 D_PrintHex<uint8_t > (l2capinbuf[13], 0x80);
106 D_PrintHex<uint8_t > (l2capinbuf[12], 0x80);
108 D_PrintHex<uint8_t > (l2capinbuf[17], 0x80);
110 D_PrintHex<uint8_t > (l2capinbuf[16], 0x80);
112 D_PrintHex<uint8_t > (l2capinbuf[15], 0x80);
114 D_PrintHex<uint8_t > (l2capinbuf[14], 0x80);
118 Notify(
PSTR(
"\r\nL2CAP Connection Request - PSM: "), 0x80);
119 D_PrintHex<uint8_t > (l2capinbuf[13], 0x80);
121 D_PrintHex<uint8_t > (l2capinbuf[12], 0x80);
123 D_PrintHex<uint8_t > (l2capinbuf[15], 0x80);
125 D_PrintHex<uint8_t > (l2capinbuf[14], 0x80);
127 D_PrintHex<uint8_t > (l2capinbuf[9], 0x80);
129 if((l2capinbuf[12] | (l2capinbuf[13] << 8)) ==
SDP_PSM) {
131 sdp_scid[0] = l2capinbuf[14];
132 sdp_scid[1] = l2capinbuf[15];
134 }
else if((l2capinbuf[12] | (l2capinbuf[13] << 8)) ==
RFCOMM_PSM) {
136 rfcomm_scid[0] = l2capinbuf[14];
137 rfcomm_scid[1] = l2capinbuf[15];
141 if((l2capinbuf[16] | (l2capinbuf[17] << 8)) == 0x0000) {
142 if(l2capinbuf[12] == sdp_dcid[0] && l2capinbuf[13] == sdp_dcid[1]) {
145 }
else if(l2capinbuf[12] == rfcomm_dcid[0] && l2capinbuf[13] == rfcomm_dcid[1]) {
151 if(l2capinbuf[12] == sdp_dcid[0] && l2capinbuf[13] == sdp_dcid[1]) {
154 }
else if(l2capinbuf[12] == rfcomm_dcid[0] && l2capinbuf[13] == rfcomm_dcid[1]) {
159 if(l2capinbuf[12] == sdp_dcid[0] && l2capinbuf[13] == sdp_dcid[1]) {
163 }
else if(l2capinbuf[12] == rfcomm_dcid[0] && l2capinbuf[13] == rfcomm_dcid[1]) {
169 if(l2capinbuf[12] == sdp_scid[0] && l2capinbuf[13] == sdp_scid[1]) {
173 }
else if(l2capinbuf[12] == rfcomm_scid[0] && l2capinbuf[13] == rfcomm_scid[1]) {
179 #ifdef DEBUG_USB_HOST
180 Notify(
PSTR(
"\r\nInformation request"), 0x80);
187 Notify(
PSTR(
"\r\nL2CAP Unknown Signaling Command: "), 0x80);
188 D_PrintHex<uint8_t > (l2capinbuf[8], 0x80);
191 }
else if(l2capinbuf[6] == sdp_dcid[0] && l2capinbuf[7] == sdp_dcid[1]) {
193 if(((l2capinbuf[16] << 8 | l2capinbuf[17]) ==
SERIALPORT_UUID) || ((l2capinbuf[16] << 8 | l2capinbuf[17]) == 0x0000 && (l2capinbuf[18] << 8 | l2capinbuf[19]) ==
SERIALPORT_UUID)) {
195 serialPortResponse1(l2capinbuf[9], l2capinbuf[10]);
196 firstMessage =
false;
198 serialPortResponse2(l2capinbuf[9], l2capinbuf[10]);
201 }
else if(((l2capinbuf[16] << 8 | l2capinbuf[17]) ==
L2CAP_UUID) || ((l2capinbuf[16] << 8 | l2capinbuf[17]) == 0x0000 && (l2capinbuf[18] << 8 | l2capinbuf[19]) ==
L2CAP_UUID)) {
203 l2capResponse1(l2capinbuf[9], l2capinbuf[10]);
204 firstMessage =
false;
206 l2capResponse2(l2capinbuf[9], l2capinbuf[10]);
210 serviceNotSupported(l2capinbuf[9], l2capinbuf[10]);
214 if((l2capinbuf[16] << 8 | l2capinbuf[17]) == 0x0000)
215 uuid = (l2capinbuf[18] << 8 | l2capinbuf[19]);
217 uuid = (l2capinbuf[16] << 8 | l2capinbuf[17]);
218 D_PrintHex<uint16_t > (uuid, 0x80);
221 uint16_t length = l2capinbuf[11] << 8 | l2capinbuf[12];
222 D_PrintHex<uint16_t > (length, 0x80);
224 for(uint8_t i = 0; i < length; i++) {
225 D_PrintHex<uint8_t > (l2capinbuf[13 + i], 0x80);
233 D_PrintHex<uint8_t > (l2capinbuf[8], 0x80);
236 }
else if(l2capinbuf[6] == rfcomm_dcid[0] && l2capinbuf[7] == rfcomm_dcid[1]) {
237 rfcommChannel = l2capinbuf[8] & 0xF8;
238 rfcommDirection = l2capinbuf[8] & 0x04;
239 rfcommCommandResponse = l2capinbuf[8] & 0x02;
240 rfcommChannelType = l2capinbuf[9] & 0xEF;
241 rfcommPfBit = l2capinbuf[9] & 0x10;
243 if(rfcommChannel >> 3 != 0x00)
244 rfcommChannelConnection = rfcommChannel;
248 D_PrintHex<uint8_t > (rfcommChannel >> 3, 0x80);
250 D_PrintHex<uint8_t > (rfcommDirection >> 2, 0x80);
252 D_PrintHex<uint8_t > (rfcommCommandResponse >> 1, 0x80);
254 D_PrintHex<uint8_t > (rfcommChannelType, 0x80);
256 D_PrintHex<uint8_t > (rfcommPfBit, 0x80);
259 #ifdef DEBUG_USB_HOST
260 Notify(
PSTR(
"\r\nReceived Disconnect RFCOMM Command on channel: "), 0x80);
261 D_PrintHex<uint8_t > (rfcommChannel >> 3, 0x80);
264 sendRfcomm(rfcommChannel, rfcommDirection, rfcommCommandResponse,
RFCOMM_UA, rfcommPfBit, rfcommbuf, 0x00);
268 if(rfcommChannelType ==
RFCOMM_UIH && rfcommChannel == rfcommChannelConnection) {
269 uint8_t length = l2capinbuf[10] >> 1;
270 uint8_t offset = l2capinbuf[4] - length - 4;
271 if(checkFcs(&l2capinbuf[8], l2capinbuf[11 + length + offset])) {
273 for(; i < length; i++) {
274 if(rfcommAvailable + i >=
sizeof (rfcommDataBuffer)) {
275 #ifdef DEBUG_USB_HOST
276 Notify(
PSTR(
"\r\nWarning: Buffer is full!"), 0x80);
280 rfcommDataBuffer[rfcommAvailable + i] = l2capinbuf[11 + i + offset];
282 rfcommAvailable += i;
284 Notify(
PSTR(
"\r\nRFCOMM Data Available: "), 0x80);
285 Notify(rfcommAvailable, 0x80);
288 D_PrintHex<uint8_t > (l2capinbuf[11], 0x80);
292 #ifdef DEBUG_USB_HOST
294 Notify(
PSTR(
"\r\nError in FCS checksum!"), 0x80);
297 for(uint8_t i = 0; i < length; i++)
298 Notifyc(l2capinbuf[i + 11 + offset], 0x80);
301 #ifdef DEBUG_USB_HOST
302 Notify(
PSTR(
"\r\nReceived UIH Remote Port Negotiation Command"), 0x80);
305 rfcommbuf[1] = l2capinbuf[12];
306 rfcommbuf[2] = l2capinbuf[13];
307 rfcommbuf[3] = l2capinbuf[14];
308 rfcommbuf[4] = l2capinbuf[15];
309 rfcommbuf[5] = l2capinbuf[16];
310 rfcommbuf[6] = l2capinbuf[17];
311 rfcommbuf[7] = l2capinbuf[18];
312 rfcommbuf[8] = l2capinbuf[19];
313 rfcommbuf[9] = l2capinbuf[20];
314 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x0A);
316 #ifdef DEBUG_USB_HOST
317 Notify(
PSTR(
"\r\nSend UIH Modem Status Response"), 0x80);
320 rfcommbuf[1] = 2 << 1 | 1;
321 rfcommbuf[2] = l2capinbuf[13];
322 rfcommbuf[3] = l2capinbuf[14];
323 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x04);
327 #ifdef DEBUG_USB_HOST
328 Notify(
PSTR(
"\r\nReceived SABM Command"), 0x80);
330 sendRfcomm(rfcommChannel, rfcommDirection, rfcommCommandResponse,
RFCOMM_UA, rfcommPfBit, rfcommbuf, 0x00);
332 #ifdef DEBUG_USB_HOST
333 Notify(
PSTR(
"\r\nReceived UIH Parameter Negotiation Command"), 0x80);
336 rfcommbuf[1] = l2capinbuf[12];
337 rfcommbuf[2] = l2capinbuf[13];
345 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x0A);
347 #ifdef DEBUG_USB_HOST
348 Notify(
PSTR(
"\r\nSend UIH Modem Status Response"), 0x80);
351 rfcommbuf[1] = 2 << 1 | 1;
352 rfcommbuf[2] = l2capinbuf[13];
353 rfcommbuf[3] = l2capinbuf[14];
354 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x04);
357 #ifdef DEBUG_USB_HOST
358 Notify(
PSTR(
"\r\nSend UIH Modem Status Command"), 0x80);
361 rfcommbuf[1] = 2 << 1 | 1;
362 rfcommbuf[2] = l2capinbuf[13];
365 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x04);
368 #ifdef DEBUG_USB_HOST
369 Notify(
PSTR(
"\r\nSend UIH Command with credit"), 0x80);
371 sendRfcommCredit(rfcommChannelConnection, rfcommDirection, 0,
RFCOMM_UIH, 0x10,
sizeof (rfcommDataBuffer));
373 timer = (uint32_t)millis();
374 waitForLastCommand =
true;
376 }
else if(rfcommChannelType ==
RFCOMM_UIH && l2capinbuf[10] == 0x01) {
377 #ifdef DEBUG_USB_HOST
378 Notify(
PSTR(
"\r\nReceived UIH Command with credit"), 0x80);
381 #ifdef DEBUG_USB_HOST
382 Notify(
PSTR(
"\r\nReceived UIH Remote Port Negotiation Command"), 0x80);
385 rfcommbuf[1] = l2capinbuf[12];
386 rfcommbuf[2] = l2capinbuf[13];
387 rfcommbuf[3] = l2capinbuf[14];
388 rfcommbuf[4] = l2capinbuf[15];
389 rfcommbuf[5] = l2capinbuf[16];
390 rfcommbuf[6] = l2capinbuf[17];
391 rfcommbuf[7] = l2capinbuf[18];
392 rfcommbuf[8] = l2capinbuf[19];
393 rfcommbuf[9] = l2capinbuf[20];
394 sendRfcomm(rfcommChannel, rfcommDirection, 0,
RFCOMM_UIH, rfcommPfBit, rfcommbuf, 0x0A);
395 #ifdef DEBUG_USB_HOST
396 Notify(
PSTR(
"\r\nRFCOMM Connection is now established\r\n"), 0x80);
402 Notify(
PSTR(
"\r\nUnsupported RFCOMM Data - ChannelType: "), 0x80);
403 D_PrintHex<uint8_t > (rfcommChannelType, 0x80);
405 D_PrintHex<uint8_t > (l2capinbuf[11], 0x80);
412 Notify(
PSTR(
"\r\nUnsupported L2CAP Data - Channel ID: "), 0x80);
413 D_PrintHex<uint8_t > (l2capinbuf[7], 0x80);
415 D_PrintHex<uint8_t > (l2capinbuf[6], 0x80);
424 if(waitForLastCommand && (int32_t)((uint32_t)millis() - timer) > 100) {
425 #ifdef DEBUG_USB_HOST
426 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);
459 SDPConnected =
false;
460 #ifdef DEBUG_USB_HOST
461 Notify(
PSTR(
"\r\nDisconnected SDP Channel"), 0x80);
469 #ifdef DEBUG_USB_HOST
470 Notify(
PSTR(
"\r\nSDP Successfully Configured"), 0x80);
480 #ifdef DEBUG_USB_HOST
481 Notify(
PSTR(
"\r\nDisconnected L2CAP Connection"), 0x80);
491 void SPP::RFCOMM_task() {
492 switch(l2cap_rfcomm_state) {
496 #ifdef DEBUG_USB_HOST
497 Notify(
PSTR(
"\r\nRFCOMM Incoming Connection Request"), 0x80);
508 RFCOMMConnected =
false;
510 #ifdef DEBUG_USB_HOST
511 Notify(
PSTR(
"\r\nDisconnected RFCOMM Channel"), 0x80);
519 #ifdef DEBUG_USB_HOST
520 Notify(
PSTR(
"\r\nRFCOMM Successfully Configured"), 0x80);
524 RFCOMMConnected =
true;
534 void SPP::SDP_Command(uint8_t* data, uint8_t nbytes) {
538 void SPP::serviceNotSupported(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
540 l2capoutbuf[1] = transactionIDHigh;
541 l2capoutbuf[2] = transactionIDLow;
542 l2capoutbuf[3] = 0x00;
543 l2capoutbuf[4] = 0x05;
544 l2capoutbuf[5] = 0x00;
545 l2capoutbuf[6] = 0x02;
548 l2capoutbuf[7] = 0x35;
549 l2capoutbuf[8] = 0x00;
550 l2capoutbuf[9] = 0x00;
552 SDP_Command(l2capoutbuf, 10);
555 void SPP::serialPortResponse1(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
557 l2capoutbuf[1] = transactionIDHigh;
558 l2capoutbuf[2] = transactionIDLow;
559 l2capoutbuf[3] = 0x00;
560 l2capoutbuf[4] = 0x2B;
561 l2capoutbuf[5] = 0x00;
562 l2capoutbuf[6] = 0x26;
565 l2capoutbuf[7] = 0x36;
566 l2capoutbuf[8] = 0x00;
567 l2capoutbuf[9] = 0x3C;
569 l2capoutbuf[10] = 0x36;
570 l2capoutbuf[11] = 0x00;
571 l2capoutbuf[12] = 0x39;
573 l2capoutbuf[13] = 0x09;
574 l2capoutbuf[14] = 0x00;
575 l2capoutbuf[15] = 0x00;
576 l2capoutbuf[16] = 0x0A;
577 l2capoutbuf[17] = 0x00;
578 l2capoutbuf[18] = 0x01;
579 l2capoutbuf[19] = 0x00;
580 l2capoutbuf[20] = 0x06;
582 l2capoutbuf[21] = 0x09;
583 l2capoutbuf[22] = 0x00;
584 l2capoutbuf[23] = 0x01;
585 l2capoutbuf[24] = 0x35;
586 l2capoutbuf[25] = 0x03;
587 l2capoutbuf[26] = 0x19;
588 l2capoutbuf[27] = 0x11;
589 l2capoutbuf[28] = 0x01;
591 l2capoutbuf[29] = 0x09;
592 l2capoutbuf[30] = 0x00;
593 l2capoutbuf[31] = 0x04;
594 l2capoutbuf[32] = 0x35;
595 l2capoutbuf[33] = 0x0C;
597 l2capoutbuf[34] = 0x35;
598 l2capoutbuf[35] = 0x03;
599 l2capoutbuf[36] = 0x19;
600 l2capoutbuf[37] = 0x01;
601 l2capoutbuf[38] = 0x00;
603 l2capoutbuf[39] = 0x35;
604 l2capoutbuf[40] = 0x05;
605 l2capoutbuf[41] = 0x19;
606 l2capoutbuf[42] = 0x00;
607 l2capoutbuf[43] = 0x03;
608 l2capoutbuf[44] = 0x08;
610 l2capoutbuf[45] = 0x02;
611 l2capoutbuf[46] = 0x00;
612 l2capoutbuf[47] = 0x19;
614 SDP_Command(l2capoutbuf, 48);
617 void SPP::serialPortResponse2(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
619 l2capoutbuf[1] = transactionIDHigh;
620 l2capoutbuf[2] = transactionIDLow;
621 l2capoutbuf[3] = 0x00;
622 l2capoutbuf[4] = 0x1C;
623 l2capoutbuf[5] = 0x00;
624 l2capoutbuf[6] = 0x19;
627 l2capoutbuf[7] = 0x01;
629 l2capoutbuf[8] = 0x09;
630 l2capoutbuf[9] = 0x00;
631 l2capoutbuf[10] = 0x06;
632 l2capoutbuf[11] = 0x35;
633 l2capoutbuf[12] = 0x09;
636 l2capoutbuf[13] = 0x09;
637 l2capoutbuf[14] = 0x65;
638 l2capoutbuf[15] = 0x6E;
642 l2capoutbuf[16] = 0x09;
643 l2capoutbuf[17] = 0x00;
644 l2capoutbuf[18] = 0x6A;
648 l2capoutbuf[19] = 0x09;
649 l2capoutbuf[20] = 0x01;
650 l2capoutbuf[21] = 0x00;
652 l2capoutbuf[22] = 0x09;
653 l2capoutbuf[23] = 0x01;
654 l2capoutbuf[24] = 0x00;
656 l2capoutbuf[25] = 0x25;
657 l2capoutbuf[26] = 0x05;
658 l2capoutbuf[27] =
'T';
659 l2capoutbuf[28] =
'K';
660 l2capoutbuf[29] =
'J';
661 l2capoutbuf[30] =
'S';
662 l2capoutbuf[31] =
'P';
663 l2capoutbuf[32] = 0x00;
665 SDP_Command(l2capoutbuf, 33);
668 void SPP::l2capResponse1(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
669 serialPortResponse1(transactionIDHigh, transactionIDLow);
672 void SPP::l2capResponse2(uint8_t transactionIDHigh, uint8_t transactionIDLow) {
673 serialPortResponse2(transactionIDHigh, transactionIDLow);
679 void SPP::RFCOMM_Command(uint8_t* data, uint8_t nbytes) {
683 void SPP::sendRfcomm(uint8_t channel, uint8_t direction, uint8_t CR, uint8_t channelType, uint8_t pfBit, uint8_t* data, uint8_t length) {
685 l2capoutbuf[1] = channelType | pfBit;
686 l2capoutbuf[2] = length << 1 | 0x01;
688 for(; i < length; i++)
689 l2capoutbuf[i + 3] = data[i];
690 l2capoutbuf[i + 3] = calcFcs(l2capoutbuf);
693 for(i = 0; i < length + 4; i++) {
694 D_PrintHex<uint8_t > (l2capoutbuf[i], 0x80);
698 RFCOMM_Command(l2capoutbuf, length + 4);
701 void SPP::sendRfcommCredit(uint8_t channel, uint8_t direction, uint8_t CR, uint8_t channelType, uint8_t pfBit, uint8_t credit) {
703 l2capoutbuf[1] = channelType | pfBit;
704 l2capoutbuf[2] = 0x01;
705 l2capoutbuf[3] = credit;
706 l2capoutbuf[4] = calcFcs(l2capoutbuf);
708 Notify(
PSTR(
" - RFCOMM Credit Data: "), 0x80);
709 for(uint8_t i = 0; i < 5; i++) {
710 D_PrintHex<uint8_t > (l2capoutbuf[i], 0x80);
714 RFCOMM_Command(l2capoutbuf, 5);
718 uint8_t SPP::crc(uint8_t *data) {
723 uint8_t SPP::calcFcs(uint8_t *data) {
724 uint8_t temp = crc(data);
726 return (0xFF - temp);
732 bool SPP::checkFcs(uint8_t *data, uint8_t fcs) {
733 uint8_t temp = crc(data);
740 #if defined(ARDUINO) && ARDUINO >=100
743 return write(&data, 1);
752 #if defined(ARDUINO) && ARDUINO >=100
757 void SPP::write(
const uint8_t *data,
size_t size) {
759 for(uint8_t i = 0; i < size; i++) {
760 if(sppIndex >=
sizeof (sppOutputBuffer) /
sizeof (sppOutputBuffer[0]))
762 sppOutputBuffer[sppIndex++] = data[i];
764 #if defined(ARDUINO) && ARDUINO >=100
775 l2capoutbuf[0] = rfcommChannelConnection | 0 | 0 |
extendAddress;
779 if(sppIndex > (
sizeof (l2capoutbuf) - 4))
780 length =
sizeof (l2capoutbuf) - 4;
784 l2capoutbuf[2] = length << 1 | 1;
786 for(; i < length; i++)
787 l2capoutbuf[i + 3] = sppOutputBuffer[i + offset];
788 l2capoutbuf[i + 3] = calcFcs(l2capoutbuf);
790 RFCOMM_Command(l2capoutbuf, length + 4);
798 return rfcommAvailable;
806 if(rfcommAvailable == 0)
808 return rfcommDataBuffer[0];
812 if(rfcommAvailable == 0)
814 uint8_t output = rfcommDataBuffer[0];
815 for(uint8_t i = 1; i < rfcommAvailable; i++)
816 rfcommDataBuffer[i - 1] = rfcommDataBuffer[i];
819 if(bytesRead > (
sizeof (rfcommDataBuffer) - 5)) {
821 sendRfcommCredit(rfcommChannelConnection, rfcommDirection, 0,
RFCOMM_UIH, 0x10,
sizeof (rfcommDataBuffer));
824 Notify((uint8_t)
sizeof (rfcommDataBuffer), 0x80);
#define L2CAP_RFCOMM_WAIT
#define L2CAP_FLAG_CONNECTION_SDP_REQUEST
#define L2CAP_SDP_SUCCESS
#define L2CAP_CMD_INFORMATION_REQUEST
#define L2CAP_CMD_DISCONNECT_REQUEST
#define L2CAP_CMD_CONFIG_REQUEST
#define L2CAP_CMD_DISCONNECT_RESPONSE
#define l2cap_check_flag(flag)
#define l2cap_set_flag(flag)
#define L2CAP_FLAG_CONNECTION_RFCOMM_REQUEST
#define L2CAP_CMD_COMMAND_REJECT
#define L2CAP_RFCOMM_SUCCESS
#define L2CAP_FLAG_CONFIG_SDP_SUCCESS
#define L2CAP_CMD_CONFIG_RESPONSE
#define L2CAP_FLAG_CONFIG_RFCOMM_SUCCESS
#define SDP_SERVICE_SEARCH_ATTRIBUTE_REQUEST
#define L2CAP_FLAG_DISCONNECT_RFCOMM_REQUEST
#define L2CAP_FLAG_DISCONNECT_SDP_REQUEST
#define l2cap_clear_flag(flag)
#define L2CAP_CMD_CONNECTION_REQUEST
#define SDP_SERVICE_SEARCH_ATTRIBUTE_RESPONSE
#define L2CAP_DISCONNECT_RESPONSE
#define L2CAP_FLAG_DISCONNECT_RESPONSE
const uint8_t rfcomm_crc_table[256]
#define BT_RFCOMM_RPN_RSP
#define BT_RFCOMM_MSC_RSP
#define BT_RFCOMM_MSC_CMD
#define BT_RFCOMM_RPN_CMD
void hci_disconnect(uint16_t handle)
void l2cap_disconnection_response(uint16_t handle, uint8_t rxid, uint8_t *dcid, uint8_t *scid)
void l2cap_config_response(uint16_t handle, uint8_t rxid, uint8_t *scid)
void l2cap_connection_response(uint16_t handle, uint8_t rxid, uint8_t *dcid, uint8_t *scid, uint8_t result)
void l2cap_information_response(uint16_t handle, uint8_t rxid, uint8_t infoTypeLow, uint8_t infoTypeHigh)
bool rfcommConnectionClaimed
void L2CAP_Command(uint16_t handle, uint8_t *data, uint8_t nbytes, uint8_t channelLow=0x01, uint8_t channelHigh=0x00)
void l2cap_config_request(uint16_t handle, uint8_t rxid, uint8_t *dcid)
void l2cap_disconnection_request(uint16_t handle, uint8_t rxid, uint8_t *dcid, uint8_t *scid)
bool sdpConnectionClaimed
bool checkHciHandle(uint8_t *buf, uint16_t handle)
void(* pFuncOnInit)(void)
uint32_t l2cap_event_flag
SPP(BTD *p, const char *name="Arduino", const char *pin="0000")
size_t write(uint8_t data)
void ACLData(uint8_t *ACLData)
#define pgm_read_byte(addr)