Ad van der Weiden / rfcomm

Dependents:   mbed_TANK_Kinect ftusbClass

RFCOMM.cpp@3:a90b1a8fd184, 2011-06-19 (annotated)

Committer:
networker
Date:
Sun Jun 19 12:36:31 2011 +0000
Revision:
3:a90b1a8fd184
Parent:
2:06b267903269
Child:
4:1c90839a1e70
minor changes

Who changed what in which revision?

UserRevisionLine numberNew contents of line
networker 0:8d7b47ceb9f5 1 #include "mbed.h"
networker 0:8d7b47ceb9f5 2 #include "Utils.h"
networker 0:8d7b47ceb9f5 3 #include "RFCOMM.h"
networker 0:8d7b47ceb9f5 4
networker 0:8d7b47ceb9f5 5 // Control field values bit no. 1 2 3 4 5 6 7 8
networker 0:8d7b47ceb9f5 6 #define BT_RFCOMM_SABM 0x3F // 1 1 1 1 P/F 1 0 0
networker 0:8d7b47ceb9f5 7 #define BT_RFCOMM_UA 0x73 // 1 1 0 0 P/F 1 1 0
networker 0:8d7b47ceb9f5 8 #define BT_RFCOMM_DM 0x0F // 1 1 1 1 P/F 0 0 0
networker 0:8d7b47ceb9f5 9 #define BT_RFCOMM_DM_PF 0x1F
networker 1:9f3821db3048 10 #define BT_RFCOMM_DISC 0x53 // 1 1 0 0 P/F 0 1 0
networker 0:8d7b47ceb9f5 11 #define BT_RFCOMM_UIH 0xEF // 1 1 1 1 P/F 1 1 1
networker 0:8d7b47ceb9f5 12 #define BT_RFCOMM_UIH_PF 0xFF
networker 0:8d7b47ceb9f5 13
networker 0:8d7b47ceb9f5 14 // Multiplexer message types
networker 0:8d7b47ceb9f5 15 #define BT_RFCOMM_PN_CMD 0x83
networker 0:8d7b47ceb9f5 16 #define BT_RFCOMM_PN_RSP 0x81
networker 0:8d7b47ceb9f5 17 #define BT_RFCOMM_TEST_CMD 0x23
networker 0:8d7b47ceb9f5 18 #define BT_RFCOMM_TEST_RSP 0x21
networker 0:8d7b47ceb9f5 19 #define BT_RFCOMM_FCON_CMD 0xA3
networker 0:8d7b47ceb9f5 20 #define BT_RFCOMM_FCON_RSP 0xA1
networker 0:8d7b47ceb9f5 21 #define BT_RFCOMM_FCOFF_CMD 0x63
networker 0:8d7b47ceb9f5 22 #define BT_RFCOMM_FCOFF_RSP 0x61
networker 0:8d7b47ceb9f5 23 #define BT_RFCOMM_MSC_CMD 0xE3
networker 0:8d7b47ceb9f5 24 #define BT_RFCOMM_MSC_RSP 0xE1
networker 0:8d7b47ceb9f5 25 #define BT_RFCOMM_RPN_CMD 0x93
networker 0:8d7b47ceb9f5 26 #define BT_RFCOMM_RPN_RSP 0x91
networker 0:8d7b47ceb9f5 27 #define BT_RFCOMM_RLS_CMD 0x53
networker 0:8d7b47ceb9f5 28 #define BT_RFCOMM_RLS_RSP 0x51
networker 0:8d7b47ceb9f5 29 #define BT_RFCOMM_NSC_RSP 0x11
networker 0:8d7b47ceb9f5 30
networker 0:8d7b47ceb9f5 31 // FCS calc
networker 0:8d7b47ceb9f5 32 #define BT_RFCOMM_CODE_WORD 0xE0 // pol = x8+x2+x1+1
networker 0:8d7b47ceb9f5 33 #define BT_RFCOMM_CRC_CHECK_LEN 3
networker 0:8d7b47ceb9f5 34 #define BT_RFCOMM_UIHCRC_CHECK_LEN 2
networker 0:8d7b47ceb9f5 35
networker 0:8d7b47ceb9f5 36 #define NR_CREDITS 1
networker 0:8d7b47ceb9f5 37 #define INITIAL_CREDITS 1 //0...7
networker 3:a90b1a8fd184 38
networker 3:a90b1a8fd184 39 #define DCD (1<<7) //DV data carrier detect
networker 3:a90b1a8fd184 40 #define RI (1<<6) //IC ring indicator
networker 3:a90b1a8fd184 41 #define RTS (1<<3) //RTR request to send
networker 3:a90b1a8fd184 42 #define DSR (1<<2) //RTC data set ready
networker 3:a90b1a8fd184 43 #define FC (1<<1) //Flow Control
networker 3:a90b1a8fd184 44 #define EA (1<<0) //extended address (always 1)
networker 3:a90b1a8fd184 45 #define SIGNALS (DCD | RTS | DSR | EA)
networker 0:8d7b47ceb9f5 46
networker 0:8d7b47ceb9f5 47 #define DEBUG 1
networker 2:06b267903269 48 #define TAKE_INITIATIVE
networker 0:8d7b47ceb9f5 49
networker 0:8d7b47ceb9f5 50 //uint8_t rfcomm_out_buffer[1000];//seems a bit big as default max framesize is 127
networker 3:a90b1a8fd184 51 //unsigned rfcomm::maxframesize = MAX_FRAME_SIZE; //only initial value
networker 0:8d7b47ceb9f5 52
networker 1:9f3821db3048 53 //these functions are obtained from rfcomm.c on google code
networker 0:8d7b47ceb9f5 54 void _bt_rfcomm_send_sabm(unsigned short source_cid, unsigned char initiator, unsigned char channel);
networker 0:8d7b47ceb9f5 55 void _bt_rfcomm_send_uih_pn_command(unsigned short source_cid, unsigned char initiator, unsigned char channel, unsigned short max_frame_size);
networker 0:8d7b47ceb9f5 56 void _bt_rfcomm_send_uih_msc_cmd(unsigned short source_cid, unsigned char initiator, unsigned char channel, unsigned char signals);
networker 1:9f3821db3048 57 void _bt_rfcomm_send_uih_rpn_cmd(uint16_t source_cid, uint8_t initiator, uint8_t dlci, port_settings *val);
networker 0:8d7b47ceb9f5 58 int rfcomm_send_packet(unsigned short source_cid, unsigned char address, unsigned char control, unsigned char credits, const unsigned char *data, unsigned short len);
networker 0:8d7b47ceb9f5 59 uint8_t crc8_calc(uint8_t *data, uint16_t len);
networker 0:8d7b47ceb9f5 60
networker 0:8d7b47ceb9f5 61
networker 0:8d7b47ceb9f5 62 //find a free socket slot for channel ch
networker 0:8d7b47ceb9f5 63 int rfcomm::find_slot(unsigned ch) {
networker 0:8d7b47ceb9f5 64 for (int i = 0; i < MAX_RFCOMM_SCKTS; i++) {
networker 0:8d7b47ceb9f5 65 if (sckts[i] != 0) { //socket is in use
networker 0:8d7b47ceb9f5 66 RFCOMMSocket *s = (RFCOMMSocket*)GetSocketInternal(sckts[i]);
networker 0:8d7b47ceb9f5 67 if (s==0) {
networker 0:8d7b47ceb9f5 68 printf("find_slot: socket %d not found\n", sckts[i]);
networker 0:8d7b47ceb9f5 69 continue;
networker 0:8d7b47ceb9f5 70 }
networker 0:8d7b47ceb9f5 71 if (s->dlci >> 1 == ch) {
networker 0:8d7b47ceb9f5 72 printf("Channel %d is already in use on socket %d\n", ch, sckts[i]);
networker 0:8d7b47ceb9f5 73 return -1;
networker 0:8d7b47ceb9f5 74 }
networker 0:8d7b47ceb9f5 75 } else //slot is free
networker 0:8d7b47ceb9f5 76 return i;
networker 0:8d7b47ceb9f5 77 }
networker 0:8d7b47ceb9f5 78 return -2; //no free slots
networker 0:8d7b47ceb9f5 79 }
networker 0:8d7b47ceb9f5 80
networker 0:8d7b47ceb9f5 81 //find the rfcomm socket for dlci
networker 0:8d7b47ceb9f5 82 RFCOMMSocket* rfcomm::find_socket(unsigned dlci) {
networker 0:8d7b47ceb9f5 83 for (int i = 0; i < MAX_RFCOMM_SCKTS; i++) {
networker 0:8d7b47ceb9f5 84 if (sckts[i] != 0) { //socket is in use
networker 0:8d7b47ceb9f5 85 RFCOMMSocket *s = (RFCOMMSocket*)GetSocketInternal(sckts[i]);
networker 0:8d7b47ceb9f5 86 if (s==0) {
networker 0:8d7b47ceb9f5 87 printf("find_socket: socket %d not found\n", sckts[i]);
networker 0:8d7b47ceb9f5 88 continue;
networker 0:8d7b47ceb9f5 89 }
networker 0:8d7b47ceb9f5 90 if (s->dlci == dlci) {
networker 0:8d7b47ceb9f5 91 return s;
networker 0:8d7b47ceb9f5 92 }
networker 0:8d7b47ceb9f5 93 }
networker 0:8d7b47ceb9f5 94 }
networker 0:8d7b47ceb9f5 95 printf("RFCOMMSocket for dlci %d was not found!\n", dlci);
networker 0:8d7b47ceb9f5 96 return 0; //socket not found
networker 0:8d7b47ceb9f5 97 }
networker 0:8d7b47ceb9f5 98
networker 0:8d7b47ceb9f5 99 //send a PN command to all sockets waiting to be opened
networker 0:8d7b47ceb9f5 100 void rfcomm::initChannels(int socket) {
networker 0:8d7b47ceb9f5 101 for (int i = 0; i < MAX_RFCOMM_SCKTS; i++) {
networker 0:8d7b47ceb9f5 102 if (sckts[i] != 0) { //socket is in use
networker 0:8d7b47ceb9f5 103 RFCOMMSocket *s = (RFCOMMSocket*)GetSocketInternal(sckts[i]);
networker 0:8d7b47ceb9f5 104 if (s==0) {
networker 0:8d7b47ceb9f5 105 printf("initChannels: socket %d not found\n", sckts[i]);
networker 0:8d7b47ceb9f5 106 continue;
networker 0:8d7b47ceb9f5 107 }
networker 0:8d7b47ceb9f5 108 if (s->State == SocketState_Opening) {
networker 0:8d7b47ceb9f5 109 printf("Sending PN for DLCI %d on socket %d\n", s->dlci, sckts[i]);
networker 0:8d7b47ceb9f5 110 _bt_rfcomm_send_uih_pn_command(socket, 1, s->dlci, maxframesize);
networker 0:8d7b47ceb9f5 111 s->State = SocketState_L2CAP_Config_wait;
networker 0:8d7b47ceb9f5 112 }
networker 0:8d7b47ceb9f5 113 }
networker 0:8d7b47ceb9f5 114 }
networker 0:8d7b47ceb9f5 115 }
networker 0:8d7b47ceb9f5 116
networker 0:8d7b47ceb9f5 117 unsigned rfcomm::release_channel(unsigned dlci) {
networker 0:8d7b47ceb9f5 118 int n = 0;
networker 0:8d7b47ceb9f5 119 for (int i = 0; i < MAX_RFCOMM_SCKTS; i++) {
networker 0:8d7b47ceb9f5 120 if (sckts[i] != 0) { //socket is in use
networker 0:8d7b47ceb9f5 121 RFCOMMSocket *s = (RFCOMMSocket*)GetSocketInternal(sckts[i]);
networker 0:8d7b47ceb9f5 122 if (s==0) {
networker 0:8d7b47ceb9f5 123 printf("Release: socket for dlci %d not found\n", dlci);
networker 0:8d7b47ceb9f5 124 continue;
networker 0:8d7b47ceb9f5 125 }
networker 0:8d7b47ceb9f5 126 if (s->dlci == dlci)
networker 0:8d7b47ceb9f5 127 sckts[i] = 0;
networker 0:8d7b47ceb9f5 128 else
networker 0:8d7b47ceb9f5 129 n++;
networker 0:8d7b47ceb9f5 130 }
networker 0:8d7b47ceb9f5 131 }
networker 0:8d7b47ceb9f5 132 return n;
networker 0:8d7b47ceb9f5 133 }
networker 0:8d7b47ceb9f5 134
networker 0:8d7b47ceb9f5 135 int rfcomm::Send(SocketInternal *sock, const u8* data, int len) {//also see if credits need to be send
networker 0:8d7b47ceb9f5 136 RFCOMMSocket *s = (RFCOMMSocket*)sock;
networker 0:8d7b47ceb9f5 137 char credits = 0;
networker 1:9f3821db3048 138 char control = BT_RFCOMM_UIH;
networker 0:8d7b47ceb9f5 139 if (len + 14 > maxframesize) //hci/l2cap header =8, rfcomm header ~ 6
networker 1:9f3821db3048 140 printf("Error! packetsize = %d, maxframesize = %d\n", len, maxframesize);
networker 0:8d7b47ceb9f5 141 if (s->peer_credits == 0) {//peer is low on credits
networker 0:8d7b47ceb9f5 142 credits = NR_CREDITS;
networker 1:9f3821db3048 143 control = BT_RFCOMM_UIH_PF;
networker 0:8d7b47ceb9f5 144 s->peer_credits += NR_CREDITS;//so provide some more
networker 0:8d7b47ceb9f5 145 }
networker 0:8d7b47ceb9f5 146 unsigned char address = (1 << 0) | (initiator << 1) | (s->dlci << 2);
networker 0:8d7b47ceb9f5 147 if (s->my_credits) {
networker 0:8d7b47ceb9f5 148 s->my_credits--;
networker 1:9f3821db3048 149 return rfcomm_send_packet(_l2cap, address, control, credits, data, len);
networker 0:8d7b47ceb9f5 150 } else
networker 1:9f3821db3048 151 return rfcomm_send_packet(_l2cap, address, control, credits, data, 0);//send an empty packet when credits run out
networker 0:8d7b47ceb9f5 152 }
networker 0:8d7b47ceb9f5 153
networker 0:8d7b47ceb9f5 154 int rfcomm::Close(SocketInternal* sock) {
networker 0:8d7b47ceb9f5 155 RFCOMMSocket *s = (RFCOMMSocket*)sock;
networker 0:8d7b47ceb9f5 156 int id = s->dlci;
networker 1:9f3821db3048 157 printf("Closing rfcomm dlci %d state=%d\n", id, s->State);
networker 0:8d7b47ceb9f5 158 Disconnect(s);
networker 0:8d7b47ceb9f5 159 int n = release_channel(id);
networker 0:8d7b47ceb9f5 160 printf("%d channels are still open\n", n);
networker 0:8d7b47ceb9f5 161 if (n == 0) {//all rfcomm channels are closed
networker 0:8d7b47ceb9f5 162 printf("....L2CAP must be closed as well\n");
networker 3:a90b1a8fd184 163 rfcomm_send_packet(_l2cap, (1 << 0) | (initiator << 1), BT_RFCOMM_DISC, 0, 0, 0); //close dlci0
networker 0:8d7b47ceb9f5 164 Socket_Close(_l2cap);
networker 0:8d7b47ceb9f5 165 _l2cap = 0; //return rfcomm to the pool
networker 0:8d7b47ceb9f5 166 }
networker 0:8d7b47ceb9f5 167 return 0;
networker 0:8d7b47ceb9f5 168 }
networker 0:8d7b47ceb9f5 169
networker 3:a90b1a8fd184 170 int rfcomm::SetOpt(SocketInternal *sock, int so, int* data, int len) {
networker 3:a90b1a8fd184 171 switch (so) {
networker 3:a90b1a8fd184 172 case SO_RECBUF:
networker 3:a90b1a8fd184 173 case SO_SNDBUF:
networker 3:a90b1a8fd184 174 maxframesize = *data; //pointless because setting takes effect only before socket is opened (before PN)
networker 3:a90b1a8fd184 175 break;
networker 3:a90b1a8fd184 176 default: return NOPROTOOPT;
networker 3:a90b1a8fd184 177 }
networker 3:a90b1a8fd184 178 return 0;
networker 3:a90b1a8fd184 179 }
networker 3:a90b1a8fd184 180
networker 3:a90b1a8fd184 181 int rfcomm::GetOpt(SocketInternal *sock, int so, int* data, int len) {
networker 3:a90b1a8fd184 182 switch (so) {
networker 3:a90b1a8fd184 183 case SO_RECBUF:
networker 3:a90b1a8fd184 184 case SO_SNDBUF:
networker 3:a90b1a8fd184 185 if (len >= sizeof(int))
networker 3:a90b1a8fd184 186 *data = maxframesize;
networker 3:a90b1a8fd184 187 break;
networker 3:a90b1a8fd184 188 default: return NOPROTOOPT;
networker 3:a90b1a8fd184 189 }
networker 3:a90b1a8fd184 190 return 0;
networker 3:a90b1a8fd184 191 }
networker 3:a90b1a8fd184 192
networker 0:8d7b47ceb9f5 193 int rfcomm::Disconnect(RFCOMMSocket *s) {
networker 0:8d7b47ceb9f5 194 unsigned char address = (1 << 0) | (initiator << 1) | (s->dlci << 2);
networker 0:8d7b47ceb9f5 195 return rfcomm_send_packet(_l2cap, address, BT_RFCOMM_DISC, 0, 0, 0);
networker 0:8d7b47ceb9f5 196 }
networker 0:8d7b47ceb9f5 197
networker 1:9f3821db3048 198 //expect this to be called with socket type=SOCKET_RFCOM and addr->psm = channel and addr->bdaddr is the BT addr
networker 1:9f3821db3048 199 //of the device to connect to.
networker 0:8d7b47ceb9f5 200 //eg. Socket_Open(SOCKET_RFCOM, rfcommaddr(bdaddr, chan), receiver_func, appl_obj);
networker 0:8d7b47ceb9f5 201 int rfcomm::Open(SocketInternal* sock, SocketAddrHdr* addr) {
networker 0:8d7b47ceb9f5 202 int ch = ((L2CAPAddr*)addr)->psm;//abused psm for channel ID
networker 0:8d7b47ceb9f5 203 RFCOMMSocket *s = (RFCOMMSocket*)sock;
networker 0:8d7b47ceb9f5 204 int slot = find_slot(ch);
networker 0:8d7b47ceb9f5 205 if (slot < 0) return 0;
networker 0:8d7b47ceb9f5 206 sckts[slot] = s->ID;
networker 0:8d7b47ceb9f5 207 s->serdevice = this;
networker 0:8d7b47ceb9f5 208 s->State = SocketState_Opening;
networker 0:8d7b47ceb9f5 209
networker 0:8d7b47ceb9f5 210 if (_l2cap == 0) { //no rfcomm -> l2cap connection yet
networker 0:8d7b47ceb9f5 211 printf("Need to open L2CAP channel first before opening RFCOMM channel %d\n", s->dlci);
networker 0:8d7b47ceb9f5 212 ((L2CAPAddr*)addr)->psm = L2CAP_PSM_RFCOMM;//open the l2cap channel and the rfcomm_ch channel
networker 0:8d7b47ceb9f5 213 initiator = 1;
networker 1:9f3821db3048 214 s->dlci = (ch<<1)|!initiator;
networker 0:8d7b47ceb9f5 215 _l2cap = Socket_Open(SOCKET_L2CAP, addr, OnRfCommControl, this);//this is the socket between the RFCOMM and the L2CAP layer
networker 0:8d7b47ceb9f5 216 if (_l2cap)
networker 0:8d7b47ceb9f5 217 printf("Successfully opened L2CAP channel on socket %d\n", _l2cap);
networker 0:8d7b47ceb9f5 218 else {
networker 0:8d7b47ceb9f5 219 printf("Opening L2CAP channel failed\n");
networker 1:9f3821db3048 220 sckts[slot] = 0;
networker 1:9f3821db3048 221 s->State = SocketState_Closed;
networker 0:8d7b47ceb9f5 222 return 0;
networker 0:8d7b47ceb9f5 223 }
networker 0:8d7b47ceb9f5 224 } else {//bypass the l2cap channel creation
networker 1:9f3821db3048 225 s->dlci = (ch<<1)|!initiator;
networker 0:8d7b47ceb9f5 226 _bt_rfcomm_send_uih_pn_command(_l2cap, initiator, s->dlci, maxframesize);
networker 1:9f3821db3048 227 s->State = SocketState_L2CAP_Config_wait;
networker 0:8d7b47ceb9f5 228 }
networker 0:8d7b47ceb9f5 229 return s->ID; //return the application unique socket nr.
networker 0:8d7b47ceb9f5 230 }
networker 1:9f3821db3048 231
networker 1:9f3821db3048 232 int rfcomm::set_remote_port_parameters(unsigned char dlci, port_settings *p) {
networker 1:9f3821db3048 233 _bt_rfcomm_send_uih_rpn_cmd(_l2cap, initiator, dlci, p);
networker 1:9f3821db3048 234 return 0;
networker 1:9f3821db3048 235 }
networker 1:9f3821db3048 236
networker 0:8d7b47ceb9f5 237 //socket is an L2CAP socket and state is the state of the L2CAP socket, not the RFCOMM socket
networker 1:9f3821db3048 238 void rfcomm::OnRfCommControl(int socket, SocketState state, const u8* data, int len, void* userData) {
networker 0:8d7b47ceb9f5 239 int packet_processed = 0;
networker 0:8d7b47ceb9f5 240 rfcomm* self = (rfcomm*)userData;
networker 1:9f3821db3048 241 const u8 initiator = self->initiator;
networker 1:9f3821db3048 242 printf("\x1B[%dm", 32); //debug: set a different colour
networker 0:8d7b47ceb9f5 243 printf("OnRfCommControl sock = %d, state = %d, length = %d\n", socket, state, len);
networker 0:8d7b47ceb9f5 244
networker 1:9f3821db3048 245 if (len == 0) {//client only
networker 0:8d7b47ceb9f5 246 if (state==SocketState_Open) {//callback after change to 'open', the rfcomm->l2cap channel is now open
networker 0:8d7b47ceb9f5 247 _bt_rfcomm_send_sabm(socket, initiator, 0); //setup the rfcomm control channel dlci==0
networker 0:8d7b47ceb9f5 248 return;
networker 0:8d7b47ceb9f5 249 }
networker 1:9f3821db3048 250 return; //or other states to handle, e.g. Closing or Closed
networker 0:8d7b47ceb9f5 251 }
networker 0:8d7b47ceb9f5 252 //we have data, so parse the header
networker 0:8d7b47ceb9f5 253 const u8 &addr = data[0];
networker 0:8d7b47ceb9f5 254 u8 dlci = addr>>2;
networker 0:8d7b47ceb9f5 255 const u8 &control = data[1];
networker 0:8d7b47ceb9f5 256 u16 length = data[2]>>1;
networker 0:8d7b47ceb9f5 257 const u8 *payload = data+3;
networker 1:9f3821db3048 258 const u8 *pFCS = data+len-1; //expected position of the CRC
networker 2:06b267903269 259 if (!(data[2]&1)) { //two byte length
networker 2:06b267903269 260 length += ((unsigned)data[3])<<7;
networker 0:8d7b47ceb9f5 261 payload++;
networker 0:8d7b47ceb9f5 262 }
networker 0:8d7b47ceb9f5 263 u8 credits = 0;
networker 1:9f3821db3048 264 if (control == BT_RFCOMM_UIH_PF)//this packet carries credits
networker 0:8d7b47ceb9f5 265 credits = *(payload++);
networker 1:9f3821db3048 266 //sanity check
networker 1:9f3821db3048 267 if (payload+length != pFCS)
networker 1:9f3821db3048 268 printf("RFCOMM size mismatch, expected %d payload bytes, got %d\n", length, pFCS-payload);
networker 0:8d7b47ceb9f5 269
networker 0:8d7b47ceb9f5 270 if (DEBUG) {
networker 1:9f3821db3048 271 printf("RFCOMM: EA=%d, C/R=%d, D=%d, ch=%d; control=%02X (P/F=%d); length=%d\n", addr&1, (addr>>1)&1, (addr>>2)&1, (addr>>3), control, (control>>4)&1, length);
networker 0:8d7b47ceb9f5 272 printfBytes("payload:", payload, length);
networker 0:8d7b47ceb9f5 273 }
networker 0:8d7b47ceb9f5 274 if (dlci == 0) { //dlci==0 control channel
networker 0:8d7b47ceb9f5 275 L2CAPSocket *s = (L2CAPSocket*)GetSocketInternal(socket);
networker 0:8d7b47ceb9f5 276 switch (control) {
networker 0:8d7b47ceb9f5 277 case BT_RFCOMM_UA:// received 1. message BT_RF_COMM_UA
networker 0:8d7b47ceb9f5 278 packet_processed++;
networker 1:9f3821db3048 279 if (s->si.State == SocketState_Closing || s->si.State==SocketState_L2CAP_WaitDisconnect) { //Confirmation of disconnect
networker 0:8d7b47ceb9f5 280 printf("Remote side confirmed disconnect for socket %d\n", s->si.ID);
networker 0:8d7b47ceb9f5 281 s->si.SetState(SocketState_Closed);
networker 0:8d7b47ceb9f5 282 break;
networker 0:8d7b47ceb9f5 283 }
networker 0:8d7b47ceb9f5 284 printf("Received RFCOMM unnumbered acknowledgement for channel 0 - multiplexer working\n");
networker 0:8d7b47ceb9f5 285 printf("Sending UIH Parameter Negotiation Command from OnRfCommControl\n");
networker 0:8d7b47ceb9f5 286 self->initChannels(socket);
networker 0:8d7b47ceb9f5 287 break;
networker 0:8d7b47ceb9f5 288 case BT_RFCOMM_UIH:// received UIH Parameter Negotiation Response
networker 0:8d7b47ceb9f5 289 switch (payload[0]) {
networker 1:9f3821db3048 290 case BT_RFCOMM_PN_RSP: {//client
networker 0:8d7b47ceb9f5 291 packet_processed++;
networker 0:8d7b47ceb9f5 292 printf("UIH Parameter Negotiation Response\n");
networker 0:8d7b47ceb9f5 293 printf("Sending SABM #%u\n", payload[2]);
networker 0:8d7b47ceb9f5 294 _bt_rfcomm_send_sabm(socket, initiator, payload[2]);//was rfcomm_ch
networker 0:8d7b47ceb9f5 295 RFCOMMSocket *r = self->find_socket(payload[2]);
networker 0:8d7b47ceb9f5 296 if (r==0) break;
networker 0:8d7b47ceb9f5 297 r->my_credits = payload[9]; //initial amount of credits
networker 3:a90b1a8fd184 298 self->maxframesize = min(self->maxframesize, payload[6] + (payload[7]<<8));
networker 3:a90b1a8fd184 299 printf("Max Frame Size = %d, got %d initial credits\n", self->maxframesize, payload[9]);
networker 0:8d7b47ceb9f5 300 }
networker 0:8d7b47ceb9f5 301 break;
networker 3:a90b1a8fd184 302 case BT_RFCOMM_PN_CMD: { //remote side sent PN command, mtu and initial credits
networker 1:9f3821db3048 303 packet_processed++;
networker 1:9f3821db3048 304 printf("UIH Parameter Negotiation Indication\n");
networker 3:a90b1a8fd184 305 self->maxframesize = min(self->maxframesize, payload[6] + (payload[7]<<8));
networker 1:9f3821db3048 306 unsigned char cred = payload[9] & 7;
networker 1:9f3821db3048 307 unsigned char _dlci = payload[2];
networker 1:9f3821db3048 308
networker 1:9f3821db3048 309 int skt = rfcomm_manager.find_socket(_dlci>>1);
networker 1:9f3821db3048 310 if (skt == 0) { //No-one is listening
networker 1:9f3821db3048 311 printf("No-one is Listening on channel %d\n", _dlci>>1);
networker 1:9f3821db3048 312 rfcomm_send_packet(socket, (_dlci<<2)|1, BT_RFCOMM_DM, 0, 0, 0);
networker 1:9f3821db3048 313 break;
networker 1:9f3821db3048 314 }
networker 1:9f3821db3048 315 RFCOMMSocket *r = (RFCOMMSocket*)GetSocketInternal(skt);
networker 1:9f3821db3048 316 r->my_credits = cred;
networker 1:9f3821db3048 317 r->peer_credits = INITIAL_CREDITS;
networker 1:9f3821db3048 318 unsigned char reply[10];
networker 1:9f3821db3048 319 memcpy(reply, payload, sizeof(reply));
networker 1:9f3821db3048 320 reply[0] = BT_RFCOMM_PN_RSP;//[1]=len, [2]=dlci, [4]=priority, [5]=timer(must be 0), [8] retransmissions (must be 0)
networker 1:9f3821db3048 321 reply[3] = payload[3]==0xF0 ? 0xE0 : 0; //support credit based flow control
networker 3:a90b1a8fd184 322 reply[6] = self->maxframesize;
networker 3:a90b1a8fd184 323 reply[7] = self->maxframesize>>8;
networker 1:9f3821db3048 324 reply[9] = payload[3]==0xF0 ? r->peer_credits : 0;
networker 3:a90b1a8fd184 325 printf("Max Frame Size = %d, give %d initial credits\n", self->maxframesize, reply[9]);
networker 1:9f3821db3048 326 rfcomm_send_packet(socket, addr^2, BT_RFCOMM_UIH, 0, reply, sizeof(reply));
networker 1:9f3821db3048 327 }
networker 1:9f3821db3048 328 break;
networker 0:8d7b47ceb9f5 329 case BT_RFCOMM_MSC_CMD:
networker 0:8d7b47ceb9f5 330 packet_processed++;
networker 0:8d7b47ceb9f5 331 {
networker 1:9f3821db3048 332 printf("Received BT_RFCOMM_MSC_IND\n");
networker 3:a90b1a8fd184 333 // fine with this, return the same status and ignore the value, there is no room in the socket to store the value, rfcomm could generate an event
networker 0:8d7b47ceb9f5 334 RFCOMMSocket *r = self->find_socket(payload[2]>>2);
networker 0:8d7b47ceb9f5 335 if (r==0) break;
networker 1:9f3821db3048 336 unsigned char reply[5];
networker 1:9f3821db3048 337 memcpy(reply, payload, 5); //keep length, dlci and value(s)
networker 0:8d7b47ceb9f5 338 reply[0] = BT_RFCOMM_MSC_RSP; // change command into response
networker 1:9f3821db3048 339 printf("Sending MSC_RSP (%d bytes)\n", length);
networker 1:9f3821db3048 340 rfcomm_send_packet(socket, addr^2, BT_RFCOMM_UIH, 0, reply, (payload[1]>>1)+2); // reply is 4 or 5 bytes
networker 0:8d7b47ceb9f5 341 switch (r->State) {
networker 0:8d7b47ceb9f5 342 case SocketState_L2CAP_Config_wait:
networker 0:8d7b47ceb9f5 343 r->State = SocketState_L2CAP_Config_wait_send;
networker 1:9f3821db3048 344 printf("Sending MSC_CMD\n");
networker 3:a90b1a8fd184 345 _bt_rfcomm_send_uih_msc_cmd(socket, initiator, payload[2]>>2, SIGNALS); // ea=1,fc=0,rtc(DSR/DTR)=1,rtr(RTS/CTs)=1,ic(RI)=0,dv(DCD)=1
networker 1:9f3821db3048 346 r->State = SocketState_L2CAP_Config_wait_rsp;
networker 0:8d7b47ceb9f5 347 break;
networker 0:8d7b47ceb9f5 348 case SocketState_L2CAP_Config_wait_reqrsp:
networker 0:8d7b47ceb9f5 349 r->State = SocketState_L2CAP_Config_wait_rsp;
networker 0:8d7b47ceb9f5 350 break;
networker 0:8d7b47ceb9f5 351 case SocketState_L2CAP_Config_wait_req:
networker 0:8d7b47ceb9f5 352 r->SetState(SocketState_Open);
networker 0:8d7b47ceb9f5 353 break;
networker 1:9f3821db3048 354 case SocketState_Open:
networker 1:9f3821db3048 355 //inform port adaptation layer
networker 1:9f3821db3048 356 printf("Received MSC IND in state Open for dlci 0x%02x\n", payload[2]>>2);
networker 1:9f3821db3048 357 break;
networker 1:9f3821db3048 358 default:
networker 1:9f3821db3048 359 printf("Received MSC IND in state %d for dlci 0x%02x\n", r->State, payload[2]>>2);
networker 0:8d7b47ceb9f5 360 }
networker 0:8d7b47ceb9f5 361 }
networker 0:8d7b47ceb9f5 362 break;
networker 0:8d7b47ceb9f5 363 case BT_RFCOMM_MSC_RSP:
networker 0:8d7b47ceb9f5 364 packet_processed++;
networker 0:8d7b47ceb9f5 365 {
networker 0:8d7b47ceb9f5 366 RFCOMMSocket *r = self->find_socket(payload[2]>>2);
networker 0:8d7b47ceb9f5 367 if (r==0) break;
networker 0:8d7b47ceb9f5 368 if (r->State == SocketState_L2CAP_Config_wait_reqrsp)
networker 0:8d7b47ceb9f5 369 r->State = SocketState_L2CAP_Config_wait_req;
networker 0:8d7b47ceb9f5 370 else if (r->State == SocketState_L2CAP_Config_wait_rsp)
networker 0:8d7b47ceb9f5 371 r->SetState(SocketState_Open);
networker 1:9f3821db3048 372 else
networker 1:9f3821db3048 373 printf("Received MSC confirmation in state %d for dlci 0x%02x\n", r->State, payload[2]>>2);
networker 0:8d7b47ceb9f5 374 }
networker 0:8d7b47ceb9f5 375 break;
networker 1:9f3821db3048 376 case BT_RFCOMM_RPN_CMD:
networker 1:9f3821db3048 377 packet_processed++;
networker 1:9f3821db3048 378 //accept and ignore all settings
networker 1:9f3821db3048 379 unsigned char reply[10];
networker 1:9f3821db3048 380 memcpy(reply, payload, length); //keep length, dlci and value(s)
networker 1:9f3821db3048 381 reply[0] = BT_RFCOMM_RPN_RSP; // change command into response
networker 1:9f3821db3048 382 printf("Responding to RPN indication (%d bytes)\n", length);
networker 1:9f3821db3048 383 rfcomm_send_packet(socket, addr^2, BT_RFCOMM_UIH, 0, reply, length);
networker 1:9f3821db3048 384 break;
networker 1:9f3821db3048 385 case BT_RFCOMM_RPN_RSP:
networker 1:9f3821db3048 386 packet_processed++;
networker 1:9f3821db3048 387 //ignore a response
networker 1:9f3821db3048 388 printf("Received RPN confirmation\n");
networker 1:9f3821db3048 389 break;
networker 0:8d7b47ceb9f5 390 default:
networker 0:8d7b47ceb9f5 391 printf("Unsupported multiplexer frame, type=%02XH\n", data[3]);
networker 0:8d7b47ceb9f5 392 }
networker 0:8d7b47ceb9f5 393 break;
networker 0:8d7b47ceb9f5 394 case BT_RFCOMM_DISC:
networker 0:8d7b47ceb9f5 395 printf("Remote site actively disconnected from DLCI0\n");
networker 0:8d7b47ceb9f5 396 rfcomm_send_packet(socket, addr|2, BT_RFCOMM_UA, 0, 0, 0);//confirm disconnection
networker 1:9f3821db3048 397 //intentional fall through
networker 0:8d7b47ceb9f5 398 case BT_RFCOMM_DM:
networker 0:8d7b47ceb9f5 399 packet_processed++;
networker 0:8d7b47ceb9f5 400 printf("Remote side refused connection on DLCI0\n");
networker 0:8d7b47ceb9f5 401 self->_l2cap = Socket_Close(socket);
networker 0:8d7b47ceb9f5 402 break;
networker 0:8d7b47ceb9f5 403 case BT_RFCOMM_SABM:
networker 1:9f3821db3048 404 packet_processed++;
networker 1:9f3821db3048 405 printf("Remote site is seeking connection on DLCI0\n"); //respond with UA
networker 1:9f3821db3048 406 rfcomm_send_packet(socket, addr|2, BT_RFCOMM_UA, 0, 0, 0);//confirm connection
networker 0:8d7b47ceb9f5 407 break;
networker 0:8d7b47ceb9f5 408 default:
networker 1:9f3821db3048 409 printf("Unexpected RFCOMM cmd %02XH for address %02XH, length=%d\n", control, addr, length);
networker 0:8d7b47ceb9f5 410 }
networker 0:8d7b47ceb9f5 411 } else { //data is for one of the serial sockets
networker 1:9f3821db3048 412 RFCOMMSocket *s = 0;
networker 1:9f3821db3048 413 if (control == BT_RFCOMM_SABM) { //req. for conn on this dlci
networker 1:9f3821db3048 414 //cannot call self->rfcomm::find_socket because it has no socket yet
networker 1:9f3821db3048 415 int skt = rfcomm_manager.find_socket(dlci>>1); //find the server socket
networker 1:9f3821db3048 416 s = (RFCOMMSocket*)GetSocketInternal(skt);//the listening socket
networker 1:9f3821db3048 417 if (s) {//move the listening socket to the appropriate rfcomm
networker 1:9f3821db3048 418 int slot = self->find_slot(dlci>>1);
networker 1:9f3821db3048 419 if (slot < 0) {
networker 1:9f3821db3048 420 printf("RFCOMM Channel %d is not free on rfcomm with l2cap socket %d\n", dlci>>1, self->_l2cap);
networker 1:9f3821db3048 421 return;
networker 1:9f3821db3048 422 }
networker 1:9f3821db3048 423 s->serdevice = self; //bind the socket to this refcomm entity
networker 1:9f3821db3048 424 self->sckts[slot] = skt;
networker 1:9f3821db3048 425 rfcomm_manager.remove_socket(skt);
networker 1:9f3821db3048 426 } else {
networker 1:9f3821db3048 427 printf("Couln't find a listening socket for dlci %d\n", dlci);
networker 1:9f3821db3048 428 return;
networker 1:9f3821db3048 429 }
networker 1:9f3821db3048 430 } else
networker 1:9f3821db3048 431 s = self->find_socket(dlci);
networker 1:9f3821db3048 432 if (s==0){
networker 1:9f3821db3048 433 printf("DLCI %d not found\n", dlci);
networker 1:9f3821db3048 434 return;
networker 1:9f3821db3048 435 }
networker 0:8d7b47ceb9f5 436 switch (control) {
networker 1:9f3821db3048 437 case BT_RFCOMM_SABM:
networker 1:9f3821db3048 438 packet_processed++;
networker 1:9f3821db3048 439 rfcomm_send_packet(socket, addr|2, BT_RFCOMM_UA, 0, 0, 0);//confirm connection
networker 1:9f3821db3048 440 s->State = SocketState_L2CAP_Config_wait; //wait for msc cmd
networker 2:06b267903269 441 #ifdef TAKE_INITIATIVE
networker 2:06b267903269 442 printf("Sending MSC_CMD\n");
networker 2:06b267903269 443 _bt_rfcomm_send_uih_msc_cmd(socket, initiator, dlci, 0x8d); // ea=1,fc=0,rtc(DSR/DTR)=1,rtr(RTS/CTs)=1,ic(RI)=0,dv(DCD)=1
networker 2:06b267903269 444 s->State = SocketState_L2CAP_Config_wait_reqrsp;
networker 2:06b267903269 445 #endif
networker 1:9f3821db3048 446 break;
networker 0:8d7b47ceb9f5 447 case BT_RFCOMM_UA:// received 2. message BT_RF_COMM_UA
networker 0:8d7b47ceb9f5 448 packet_processed++;
networker 0:8d7b47ceb9f5 449 if (s->State == SocketState_Closing) { //Confirmation of disconnect
networker 0:8d7b47ceb9f5 450 printf("Remote side confirmed disconnect for socket %d\n", s->ID);
networker 0:8d7b47ceb9f5 451 s->SetState(SocketState_Closed);
networker 0:8d7b47ceb9f5 452 break;
networker 0:8d7b47ceb9f5 453 }
networker 0:8d7b47ceb9f5 454 printf("Received RFCOMM unnumbered acknowledgement for dlci %u - channel opened\n", dlci);
networker 0:8d7b47ceb9f5 455 if (s->State == SocketState_L2CAP_Config_wait) {
networker 1:9f3821db3048 456 printf("Sending MSC CMD\n");
networker 0:8d7b47ceb9f5 457 _bt_rfcomm_send_uih_msc_cmd(socket, initiator, dlci, 0x8d); // ea=1,fc=0,rtc(DSR/DTR)=1,rtr(RTS/CTs)=1,ic(RI)=0,dv(DCD)=1
networker 0:8d7b47ceb9f5 458 s->State = SocketState_L2CAP_Config_wait_reqrsp;
networker 0:8d7b47ceb9f5 459 }
networker 0:8d7b47ceb9f5 460 break;
networker 0:8d7b47ceb9f5 461 case BT_RFCOMM_UIH_PF: //user data with credits
networker 0:8d7b47ceb9f5 462 printf("Got %u credits\n", credits);
networker 0:8d7b47ceb9f5 463 s->my_credits += credits;
networker 1:9f3821db3048 464 //intentional fall-through
networker 0:8d7b47ceb9f5 465 case BT_RFCOMM_UIH: //user data
networker 0:8d7b47ceb9f5 466 packet_processed++;
networker 0:8d7b47ceb9f5 467 if (DEBUG) {
networker 0:8d7b47ceb9f5 468 printf("RX: address %02x, control %02x: ", addr, control);
networker 1:9f3821db3048 469 printHex( payload, length);
networker 0:8d7b47ceb9f5 470 }
networker 1:9f3821db3048 471 if (length) {
networker 0:8d7b47ceb9f5 472 s->peer_credits--;
networker 1:9f3821db3048 473 s->Recv(payload, length);
networker 0:8d7b47ceb9f5 474 } else
networker 0:8d7b47ceb9f5 475 printf("Received empty packet\n");
networker 1:9f3821db3048 476 if (length == 0 || s->peer_credits == 0) {//send credits when peer runs out
networker 1:9f3821db3048 477 //char ini = !(dlci & 1);
networker 1:9f3821db3048 478 unsigned char address = (1 << 0) | (initiator << 1) | (dlci << 2);
networker 1:9f3821db3048 479 printf("send %d credits to dlci %d\n", NR_CREDITS, addr>>2);
networker 0:8d7b47ceb9f5 480 rfcomm_send_packet(socket, address, BT_RFCOMM_UIH_PF, NR_CREDITS, NULL, 0);
networker 0:8d7b47ceb9f5 481 s->peer_credits += NR_CREDITS;
networker 0:8d7b47ceb9f5 482 }
networker 0:8d7b47ceb9f5 483 break;
networker 1:9f3821db3048 484 case BT_RFCOMM_DISC:
networker 1:9f3821db3048 485 packet_processed++;
networker 1:9f3821db3048 486 printf("Received DISC IND for dlci %d\n", dlci);
networker 1:9f3821db3048 487 rfcomm_send_packet(socket, addr, BT_RFCOMM_UA, 0, 0, 0);//confirm disconnection
networker 1:9f3821db3048 488 s->SetState(SocketState_Closed);
networker 1:9f3821db3048 489 break;
networker 1:9f3821db3048 490 case BT_RFCOMM_DM:
networker 1:9f3821db3048 491 case BT_RFCOMM_DM_PF:
networker 1:9f3821db3048 492 packet_processed++;
networker 1:9f3821db3048 493 printf("Received DM IND (%02X) for dlci %d\n", control, dlci);
networker 1:9f3821db3048 494 s->SetState(SocketState_Closed);
networker 1:9f3821db3048 495 break;
networker 0:8d7b47ceb9f5 496 default:
networker 0:8d7b47ceb9f5 497 printf("Unexpected RFCOMM cmd %02XH for address %02XH, length=%d\n", control, addr, length);
networker 0:8d7b47ceb9f5 498 }
networker 0:8d7b47ceb9f5 499 }
networker 0:8d7b47ceb9f5 500
networker 0:8d7b47ceb9f5 501 if (!packet_processed) {
networker 0:8d7b47ceb9f5 502 // just dump data for now
networker 0:8d7b47ceb9f5 503 printf("??: address %02x, control %02x: ", data[0], data[1]);
networker 0:8d7b47ceb9f5 504 printHex( data, len );
networker 0:8d7b47ceb9f5 505 }
networker 1:9f3821db3048 506 printf("\x1B[%dm", 0);//reset terminal colour
networker 0:8d7b47ceb9f5 507 }
networker 0:8d7b47ceb9f5 508
networker 3:a90b1a8fd184 509 //should make the functions below member functions
networker 3:a90b1a8fd184 510
networker 0:8d7b47ceb9f5 511 /**
networker 0:8d7b47ceb9f5 512 * @param credits - only used for RFCOMM flow control in UIH wiht P/F = 1
networker 0:8d7b47ceb9f5 513 */
networker 1:9f3821db3048 514 /* Questionable optimisation. When OFFSET==8 a buffer is (dynamically) allocated that provides space for the lower
networker 1:9f3821db3048 515 layer headers, this reduces copying to, and allocation of, a lower layer buffer. However, all other layers using
networker 1:9f3821db3048 516 HCI/L2CAP must do the same.
networker 1:9f3821db3048 517 */
networker 0:8d7b47ceb9f5 518 #define OFFSET 8
networker 1:9f3821db3048 519
networker 0:8d7b47ceb9f5 520 int rfcomm_send_packet(uint16_t source_cid, uint8_t address, uint8_t control, uint8_t credits, const uint8_t *data, uint16_t len) {
networker 0:8d7b47ceb9f5 521
networker 0:8d7b47ceb9f5 522 uint16_t pos = OFFSET;
networker 0:8d7b47ceb9f5 523 uint8_t crc_fields = 3;
networker 0:8d7b47ceb9f5 524
networker 0:8d7b47ceb9f5 525 #if OFFSET == 8
networker 0:8d7b47ceb9f5 526 uint8_t* rfcomm_out_buffer = new uint8_t[OFFSET+len+6];
networker 0:8d7b47ceb9f5 527 #else
networker 0:8d7b47ceb9f5 528 static uint8_t rfcomm_out_buffer[MAXFRAMESIZE+6];//seems a bit big as default max framesize is 127
networker 0:8d7b47ceb9f5 529 #endif
networker 0:8d7b47ceb9f5 530 rfcomm_out_buffer[pos++] = address;
networker 0:8d7b47ceb9f5 531 rfcomm_out_buffer[pos++] = control;
networker 0:8d7b47ceb9f5 532
networker 0:8d7b47ceb9f5 533 // length field can be 1 or 2 octets
networker 0:8d7b47ceb9f5 534 if (len < 128) {
networker 0:8d7b47ceb9f5 535 rfcomm_out_buffer[pos++] = (len << 1)| 1; // bits 0-6
networker 0:8d7b47ceb9f5 536 } else {
networker 0:8d7b47ceb9f5 537 rfcomm_out_buffer[pos++] = (len & 0x7f) << 1; // bits 0-6
networker 0:8d7b47ceb9f5 538 rfcomm_out_buffer[pos++] = len >> 7; // bits 7-14
networker 0:8d7b47ceb9f5 539 crc_fields++;
networker 0:8d7b47ceb9f5 540 }
networker 0:8d7b47ceb9f5 541
networker 0:8d7b47ceb9f5 542 // add credits for UIH frames when PF bit is set
networker 0:8d7b47ceb9f5 543 if (control == BT_RFCOMM_UIH_PF) {
networker 0:8d7b47ceb9f5 544 rfcomm_out_buffer[pos++] = credits;
networker 0:8d7b47ceb9f5 545 }
networker 0:8d7b47ceb9f5 546
networker 0:8d7b47ceb9f5 547 // copy actual data
networker 0:8d7b47ceb9f5 548 memcpy(&rfcomm_out_buffer[pos], data, len);
networker 0:8d7b47ceb9f5 549 pos += len;
networker 0:8d7b47ceb9f5 550
networker 0:8d7b47ceb9f5 551 // UIH frames only calc FCS over address + control (5.1.1)
networker 0:8d7b47ceb9f5 552 if ((control & 0xef) == BT_RFCOMM_UIH) {
networker 0:8d7b47ceb9f5 553 crc_fields = 2;
networker 0:8d7b47ceb9f5 554 }
networker 1:9f3821db3048 555 rfcomm_out_buffer[pos++] = crc8_calc(rfcomm_out_buffer+OFFSET, crc_fields); // calc fcs
networker 0:8d7b47ceb9f5 556 int retval = Socket_Send( source_cid, rfcomm_out_buffer, pos);
networker 0:8d7b47ceb9f5 557 #if OFFSET == 8
networker 0:8d7b47ceb9f5 558 delete[] rfcomm_out_buffer;
networker 0:8d7b47ceb9f5 559 #endif
networker 0:8d7b47ceb9f5 560 if (retval <= 0)
networker 1:9f3821db3048 561 return retval;
networker 0:8d7b47ceb9f5 562 return len;//return the size of the payload
networker 0:8d7b47ceb9f5 563 }
networker 0:8d7b47ceb9f5 564
networker 0:8d7b47ceb9f5 565 void _bt_rfcomm_send_sabm(uint16_t source_cid, uint8_t initiator, uint8_t dlci) {
networker 0:8d7b47ceb9f5 566 uint8_t address = (1 << 0) | (initiator << 1) | (dlci << 2);
networker 0:8d7b47ceb9f5 567 rfcomm_send_packet(source_cid, address, BT_RFCOMM_SABM, 0, NULL, 0);
networker 0:8d7b47ceb9f5 568 }
networker 0:8d7b47ceb9f5 569
networker 0:8d7b47ceb9f5 570 void _bt_rfcomm_send_uih_pn_command(uint16_t source_cid, uint8_t initiator, uint8_t dlci, uint16_t max_frame_size) {
networker 0:8d7b47ceb9f5 571 uint8_t payload[10];
networker 0:8d7b47ceb9f5 572 uint8_t address = (1 << 0) | (initiator << 1); // EA and C/R bit set - always server channel 0
networker 0:8d7b47ceb9f5 573 uint8_t pos = 0;
networker 0:8d7b47ceb9f5 574 payload[pos++] = BT_RFCOMM_PN_CMD;
networker 0:8d7b47ceb9f5 575 payload[pos++] = 8 << 1 | 1; // len
networker 0:8d7b47ceb9f5 576 payload[pos++] = dlci;
networker 0:8d7b47ceb9f5 577 payload[pos++] = 0xf0; // pre defined for Bluetooth, see 5.5.3 of TS 07.10 Adaption for RFCOMM
networker 0:8d7b47ceb9f5 578 payload[pos++] = 0; // priority
networker 0:8d7b47ceb9f5 579 payload[pos++] = 0; // max 60 seconds ack
networker 0:8d7b47ceb9f5 580 payload[pos++] = max_frame_size & 0xff; // max framesize low
networker 0:8d7b47ceb9f5 581 payload[pos++] = max_frame_size >> 8; // max framesize high
networker 0:8d7b47ceb9f5 582 payload[pos++] = 0x00; // number of retransmissions
networker 0:8d7b47ceb9f5 583 payload[pos++] = INITIAL_CREDITS; // unused error recovery window
networker 0:8d7b47ceb9f5 584 rfcomm_send_packet(source_cid, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos);
networker 0:8d7b47ceb9f5 585 }
networker 0:8d7b47ceb9f5 586
networker 0:8d7b47ceb9f5 587 void _bt_rfcomm_send_uih_data(uint16_t source_cid, uint8_t initiator, uint8_t channel, uint8_t *data, uint16_t len) {
networker 0:8d7b47ceb9f5 588 uint8_t address = (1 << 0) | (initiator << 1) | (!initiator << 2) | (channel << 3);
networker 0:8d7b47ceb9f5 589 rfcomm_send_packet(source_cid, address, BT_RFCOMM_UIH, 0, data, len);
networker 0:8d7b47ceb9f5 590 }
networker 0:8d7b47ceb9f5 591
networker 0:8d7b47ceb9f5 592 void _bt_rfcomm_send_uih_msc_cmd(uint16_t source_cid, uint8_t initiator, uint8_t dlci, uint8_t signals) {
networker 0:8d7b47ceb9f5 593 uint8_t address = (1 << 0) | (initiator << 1); // EA and C/R bit set - always server channel 0
networker 1:9f3821db3048 594 uint8_t payload[5];
networker 0:8d7b47ceb9f5 595 uint8_t pos = 0;
networker 0:8d7b47ceb9f5 596 payload[pos++] = BT_RFCOMM_MSC_CMD;
networker 1:9f3821db3048 597 payload[pos++] = 2 << 1 | 1; // len, should be adapted when adding break byte
networker 1:9f3821db3048 598 payload[pos++] = (1 << 0) | (1 << 1) | (dlci << 2); //C/R is always 1
networker 0:8d7b47ceb9f5 599 payload[pos++] = signals;
networker 1:9f3821db3048 600 // payload[pos++] = brk;
networker 0:8d7b47ceb9f5 601 rfcomm_send_packet(source_cid, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos);
networker 0:8d7b47ceb9f5 602 }
networker 0:8d7b47ceb9f5 603
networker 1:9f3821db3048 604 void _bt_rfcomm_send_uih_rpn_cmd(uint16_t source_cid, uint8_t initiator, uint8_t dlci, port_settings *val) {
networker 1:9f3821db3048 605 uint8_t address = (1 << 0) | (initiator << 1); // EA and C/R bit set - always server channel 0
networker 1:9f3821db3048 606 uint8_t payload[sizeof(port_settings)+3];
networker 1:9f3821db3048 607 uint8_t pos = 0;
networker 1:9f3821db3048 608 payload[pos++] = BT_RFCOMM_RPN_CMD;//type
networker 1:9f3821db3048 609 if (val) {
networker 1:9f3821db3048 610 payload[pos++] = ((1+sizeof(port_settings)) << 1) | 1; // len
networker 1:9f3821db3048 611 payload[pos++] = (1 << 0) | (1 << 1) | (dlci << 2);
networker 1:9f3821db3048 612 memcpy(payload+pos, (char*)val, sizeof(port_settings));
networker 1:9f3821db3048 613 pos += sizeof(port_settings);
networker 1:9f3821db3048 614 } else {
networker 1:9f3821db3048 615 payload[pos++] = (1 << 1) | 1; // len
networker 1:9f3821db3048 616 payload[pos++] = (1 << 0) | (1 << 1) | (dlci << 2);
networker 1:9f3821db3048 617 }
networker 1:9f3821db3048 618 rfcomm_send_packet(source_cid, address, BT_RFCOMM_UIH, 0, (uint8_t *) payload, pos);
networker 1:9f3821db3048 619 }
networker 1:9f3821db3048 620
networker 1:9f3821db3048 621 int set_remote_port_parameters(int socket, port_settings *p) {
networker 1:9f3821db3048 622 RFCOMMSocket* si = (RFCOMMSocket*)GetSocketInternal(socket);//gets the RFCOMM socket
networker 1:9f3821db3048 623 if (!si || si->ID != socket)
networker 1:9f3821db3048 624 return ERR_SOCKET_NOT_FOUND;
networker 1:9f3821db3048 625 return si->serdevice->set_remote_port_parameters(si->dlci, p);
networker 1:9f3821db3048 626 }
networker 1:9f3821db3048 627
networker 1:9f3821db3048 628
networker 0:8d7b47ceb9f5 629 /*
networker 0:8d7b47ceb9f5 630 * CRC (reversed crc) lookup table as calculated by the table generator in ETSI TS 101 369 V6.3.0.
networker 0:8d7b47ceb9f5 631 */
networker 0:8d7b47ceb9f5 632 static const uint8_t crc8table[256] = { /* reversed, 8-bit, poly=0x07 */
networker 0:8d7b47ceb9f5 633 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75, 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
networker 0:8d7b47ceb9f5 634 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69, 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
networker 0:8d7b47ceb9f5 635 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D, 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
networker 0:8d7b47ceb9f5 636 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51, 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
networker 0:8d7b47ceb9f5 637 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05, 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
networker 0:8d7b47ceb9f5 638 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19, 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
networker 0:8d7b47ceb9f5 639 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D, 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
networker 0:8d7b47ceb9f5 640 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21, 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
networker 0:8d7b47ceb9f5 641 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95, 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
networker 0:8d7b47ceb9f5 642 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89, 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
networker 0:8d7b47ceb9f5 643 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD, 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
networker 0:8d7b47ceb9f5 644 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1, 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
networker 0:8d7b47ceb9f5 645 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5, 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
networker 0:8d7b47ceb9f5 646 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9, 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
networker 0:8d7b47ceb9f5 647 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD, 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
networker 0:8d7b47ceb9f5 648 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1, 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
networker 0:8d7b47ceb9f5 649 };
networker 0:8d7b47ceb9f5 650
networker 0:8d7b47ceb9f5 651 #define CRC8_INIT 0xFF // Initial FCS value
networker 0:8d7b47ceb9f5 652 #define CRC8_OK 0xCF // Good final FCS value
networker 0:8d7b47ceb9f5 653 /*-----------------------------------------------------------------------------------*/
networker 0:8d7b47ceb9f5 654 uint8_t crc8(uint8_t *data, uint16_t len) {
networker 0:8d7b47ceb9f5 655 uint16_t count;
networker 0:8d7b47ceb9f5 656 uint8_t crc = CRC8_INIT;
networker 0:8d7b47ceb9f5 657 for (count = 0; count < len; count++)
networker 0:8d7b47ceb9f5 658 crc = crc8table[crc ^ data[count]];
networker 0:8d7b47ceb9f5 659 return crc;
networker 0:8d7b47ceb9f5 660 }
networker 0:8d7b47ceb9f5 661
networker 0:8d7b47ceb9f5 662 /*-----------------------------------------------------------------------------------*/
networker 0:8d7b47ceb9f5 663 uint8_t crc8_check(uint8_t *data, uint16_t len, uint8_t check_sum) {
networker 0:8d7b47ceb9f5 664 uint8_t crc;
networker 0:8d7b47ceb9f5 665
networker 0:8d7b47ceb9f5 666 crc = crc8(data, len);
networker 0:8d7b47ceb9f5 667
networker 0:8d7b47ceb9f5 668 crc = crc8table[crc ^ check_sum];
networker 0:8d7b47ceb9f5 669 if (crc == CRC8_OK)
networker 0:8d7b47ceb9f5 670 return 0; /* Valid */
networker 0:8d7b47ceb9f5 671 else
networker 0:8d7b47ceb9f5 672 return 1; /* Failed */
networker 0:8d7b47ceb9f5 673
networker 0:8d7b47ceb9f5 674 }
networker 0:8d7b47ceb9f5 675
networker 0:8d7b47ceb9f5 676 /*-----------------------------------------------------------------------------------*/
networker 0:8d7b47ceb9f5 677 uint8_t crc8_calc(uint8_t *data, uint16_t len) {
networker 0:8d7b47ceb9f5 678 /* Ones complement */
networker 0:8d7b47ceb9f5 679 return 0xFF - crc8(data, len);
networker 0:8d7b47ceb9f5 680 }